﻿/********************************************************************************/
/*										*/
/*			  TPM Part 2 Headers	   				*/
/*			     Written by Ken Goldman				*/
/*		       IBM Thomas J. Watson Research Center			*/
/*            $Id: TpmTypes.h 1532 2019-11-26 14:28:36Z kgoldman $		*/
/*										*/
/*  Licenses and Notices							*/
/*										*/
/*  1. Copyright Licenses:							*/
/*										*/
/*  - Trusted Computing Group (TCG) grants to the user of the source code in	*/
/*    this specification (the "Source Code") a worldwide, irrevocable, 		*/
/*    nonexclusive, royalty free, copyright license to reproduce, create 	*/
/*    derivative works, distribute, display and perform the Source Code and	*/
/*    derivative works thereof, and to grant others the rights granted herein.	*/
/*										*/
/*  - The TCG grants to the user of the other parts of the specification 	*/
/*    (other than the Source Code) the rights to reproduce, distribute, 	*/
/*    display, and perform the specification solely for the purpose of 		*/
/*    developing products based on such documents.				*/
/*										*/
/*  2. Source Code Distribution Conditions:					*/
/*										*/
/*  - Redistributions of Source Code must retain the above copyright licenses, 	*/
/*    this list of conditions and the following disclaimers.			*/
/*										*/
/*  - Redistributions in binary form must reproduce the above copyright 	*/
/*    licenses, this list of conditions	and the following disclaimers in the 	*/
/*    documentation and/or other materials provided with the distribution.	*/
/*										*/
/*  3. Disclaimers:								*/
/*										*/
/*  - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF	*/
/*  LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH	*/
/*  RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES)	*/
/*  THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE.		*/
/*  Contact TCG Administration (admin@trustedcomputinggroup.org) for 		*/
/*  information on specification licensing rights available through TCG 	*/
/*  membership agreements.							*/
/*										*/
/*  - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED 	*/
/*    WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR 	*/
/*    FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR 		*/
/*    NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY 		*/
/*    OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE.		*/
/*										*/
/*  - Without limitation, TCG and its members and licensors disclaim all 	*/
/*    liability, including liability for infringement of any proprietary 	*/
/*    rights, relating to use of information in this specification and to the	*/
/*    implementation of this specification, and TCG disclaims all liability for	*/
/*    cost of procurement of substitute goods or services, lost profits, loss 	*/
/*    of use, loss of data or any incidental, consequential, direct, indirect, 	*/
/*    or special damages, whether under contract, tort, warranty or otherwise, 	*/
/*    arising in any way out of use or reliance upon this specification or any 	*/
/*    information herein.							*/
/*										*/
/*  (c) Copyright IBM Corp. and others, 2016 - 2019				*/
/*										*/
/********************************************************************************/

/* 5.21	TpmTypes.h */

#ifndef TPMTYPES_H
#define TPMTYPES_H


#define  USE_BIT_FIELD_STRUCTURES    0  
#ifndef ALG_ECC
#define ALG_ECC                      1
#endif
// #define HASH_COUNT			(ALG_SHA1   + ALG_SHA256   + ALG_SHA384   + ALG_SHA3_256  +ALG_SHA3_384 + ALG_SHA3_512 + ALG_SHA512   + ALG_SM3_256)


/* Capabilities.h */
#ifndef     _CAPABILITIES_H
#define     _CAPABILITIES_H


#define    MAX_CAP_DATA         (MAX_CAP_BUFFER - sizeof(TPM_CAP)-sizeof(UINT32))
#define    MAX_CAP_ALGS         (MAX_CAP_DATA / sizeof(TPMS_ALG_PROPERTY))
#define    MAX_CAP_HANDLES      (MAX_CAP_DATA / sizeof(TPM_HANDLE))
#define    MAX_CAP_CC           (MAX_CAP_DATA / sizeof(TPM_CC))
#define    MAX_TPM_PROPERTIES   (MAX_CAP_DATA / sizeof(TPMS_TAGGED_PROPERTY))
#define    MAX_PCR_PROPERTIES   (MAX_CAP_DATA / sizeof(TPMS_TAGGED_PCR_SELECT))
#define    MAX_ECC_CURVES       (MAX_CAP_DATA / sizeof(TPM_ECC_CURVE))
#define    MAX_TAGGED_POLICIES  (MAX_CAP_DATA / sizeof(TPMS_TAGGED_POLICY))
#define    MAX_ACT_DATA		(MAX_CAP_DATA / sizeof(TPMS_ACT_DATA))
#define    MAX_AC_CAPABILITIES  (MAX_CAP_DATA / sizeof(TPMS_AC_OUTPUT))

#endif
/* Capabilities.h */

/* Table 1:2 - Definition of TPM_ALG_ID Constants */

typedef UINT16                          TPM_ALG_ID;
#define TYPE_OF_TPM_ALG_ID              UINT16
#define     ALG_ERROR_VALUE             0x0000
#define TPM_ALG_ERROR                   (TPM_ALG_ID)(ALG_ERROR_VALUE)
#define     ALG_RSA_VALUE               0x0001
#define TPM_ALG_RSA                     (TPM_ALG_ID)(ALG_RSA_VALUE)
#define     ALG_TDES_VALUE              0x0003
#define TPM_ALG_TDES                    (TPM_ALG_ID)(ALG_TDES_VALUE)
#define     ALG_SHA_VALUE               0x0004
#define TPM_ALG_SHA                     (TPM_ALG_ID)(ALG_SHA_VALUE)
#define     ALG_SHA1_VALUE              0x0004
#define TPM_ALG_SHA1                    (TPM_ALG_ID)(ALG_SHA1_VALUE)
#define     ALG_HMAC_VALUE              0x0005
#define TPM_ALG_HMAC                    (TPM_ALG_ID)(ALG_HMAC_VALUE)
#define     ALG_AES_VALUE               0x0006
#define TPM_ALG_AES                     (TPM_ALG_ID)(ALG_AES_VALUE)
#define     ALG_MGF1_VALUE              0x0007
#define TPM_ALG_MGF1                    (TPM_ALG_ID)(ALG_MGF1_VALUE)
#define     ALG_KEYEDHASH_VALUE         0x0008
#define TPM_ALG_KEYEDHASH               (TPM_ALG_ID)(ALG_KEYEDHASH_VALUE)
#define     ALG_XOR_VALUE               0x000A
#define TPM_ALG_XOR                     (TPM_ALG_ID)(ALG_XOR_VALUE)
#define     ALG_SHA256_VALUE            0x000B
#define TPM_ALG_SHA256                  (TPM_ALG_ID)(ALG_SHA256_VALUE)
#define     ALG_SHA384_VALUE            0x000C
#define TPM_ALG_SHA384                  (TPM_ALG_ID)(ALG_SHA384_VALUE)
#define     ALG_SHA512_VALUE            0x000D
#define TPM_ALG_SHA512                  (TPM_ALG_ID)(ALG_SHA512_VALUE)
#define     ALG_NULL_VALUE              0x0010
#define TPM_ALG_NULL                    (TPM_ALG_ID)(ALG_NULL_VALUE)
#define     ALG_SM3_256_VALUE           0x0012
#define TPM_ALG_SM3_256                 (TPM_ALG_ID)(ALG_SM3_256_VALUE)
#define     ALG_SM4_VALUE               0x0013
#define TPM_ALG_SM4                     (TPM_ALG_ID)(ALG_SM4_VALUE)
#define     ALG_RSASSA_VALUE            0x0014
#define TPM_ALG_RSASSA                  (TPM_ALG_ID)(ALG_RSASSA_VALUE)
#define     ALG_RSAES_VALUE             0x0015
#define TPM_ALG_RSAES                   (TPM_ALG_ID)(ALG_RSAES_VALUE)
#define     ALG_RSAPSS_VALUE            0x0016
#define TPM_ALG_RSAPSS                  (TPM_ALG_ID)(ALG_RSAPSS_VALUE)
#define     ALG_OAEP_VALUE              0x0017
#define TPM_ALG_OAEP                    (TPM_ALG_ID)(ALG_OAEP_VALUE)
#define     ALG_ECDSA_VALUE             0x0018
#define TPM_ALG_ECDSA                   (TPM_ALG_ID)(ALG_ECDSA_VALUE)
#define     ALG_ECDH_VALUE              0x0019
#define TPM_ALG_ECDH                    (TPM_ALG_ID)(ALG_ECDH_VALUE)
#define     ALG_ECDAA_VALUE             0x001A
#define TPM_ALG_ECDAA                   (TPM_ALG_ID)(ALG_ECDAA_VALUE)
#define     ALG_SM2_VALUE               0x001B
#define TPM_ALG_SM2                     (TPM_ALG_ID)(ALG_SM2_VALUE)
#define     ALG_ECSCHNORR_VALUE         0x001C
#define TPM_ALG_ECSCHNORR               (TPM_ALG_ID)(ALG_ECSCHNORR_VALUE)
#define     ALG_ECMQV_VALUE             0x001D
#define TPM_ALG_ECMQV                   (TPM_ALG_ID)(ALG_ECMQV_VALUE)
#define     ALG_KDF1_SP800_56A_VALUE    0x0020
#define TPM_ALG_KDF1_SP800_56A          (TPM_ALG_ID)(ALG_KDF1_SP800_56A_VALUE)
#define     ALG_KDF2_VALUE              0x0021
#define TPM_ALG_KDF2                    (TPM_ALG_ID)(ALG_KDF2_VALUE)
#define     ALG_KDF1_SP800_108_VALUE    0x0022
#define TPM_ALG_KDF1_SP800_108          (TPM_ALG_ID)(ALG_KDF1_SP800_108_VALUE)
#define     ALG_ECC_VALUE               0x0023
#define TPM_ALG_ECC                     (TPM_ALG_ID)(ALG_ECC_VALUE)
#define     ALG_SYMCIPHER_VALUE         0x0025
#define TPM_ALG_SYMCIPHER               (TPM_ALG_ID)(ALG_SYMCIPHER_VALUE)
#define     ALG_CAMELLIA_VALUE          0x0026
#define TPM_ALG_CAMELLIA                (TPM_ALG_ID)(ALG_CAMELLIA_VALUE)
#define     ALG_SHA3_256_VALUE          0x0027
#define TPM_ALG_SHA3_256                (TPM_ALG_ID)(ALG_SHA3_256_VALUE)
#define     ALG_SHA3_384_VALUE          0x0028
#define TPM_ALG_SHA3_384                (TPM_ALG_ID)(ALG_SHA3_384_VALUE)
#define     ALG_SHA3_512_VALUE          0x0029
#define TPM_ALG_SHA3_512                (TPM_ALG_ID)(ALG_SHA3_512_VALUE)
#define     ALG_CMAC_VALUE              0x003F
#define TPM_ALG_CMAC                    (TPM_ALG_ID)(ALG_CMAC_VALUE)
#define     ALG_CTR_VALUE               0x0040
#define TPM_ALG_CTR                     (TPM_ALG_ID)(ALG_CTR_VALUE)
#define     ALG_OFB_VALUE               0x0041
#define TPM_ALG_OFB                     (TPM_ALG_ID)(ALG_OFB_VALUE)
#define     ALG_CBC_VALUE               0x0042
#define TPM_ALG_CBC                     (TPM_ALG_ID)(ALG_CBC_VALUE)
#define     ALG_CFB_VALUE               0x0043
#define TPM_ALG_CFB                     (TPM_ALG_ID)(ALG_CFB_VALUE)
#define     ALG_ECB_VALUE               0x0044
#define TPM_ALG_ECB                     (TPM_ALG_ID)(ALG_ECB_VALUE)

/* Values derived from Table 1:2 */
#define     ALG_FIRST_VALUE             0x0001
#define TPM_ALG_FIRST                   (TPM_ALG_ID)(ALG_FIRST_VALUE)
#define     ALG_LAST_VALUE              0x0044
#define TPM_ALG_LAST                    (TPM_ALG_ID)(ALG_LAST_VALUE)

/* Table 1:3 - Definition of TPM_ECC_CURVE Constants */
typedef UINT16              TPM_ECC_CURVE;
#define TYPE_OF_TPM_ECC_CURVE   UINT16
#define TPM_ECC_NONE        (TPM_ECC_CURVE)(0x0000)
#define TPM_ECC_NIST_P192   (TPM_ECC_CURVE)(0x0001)
#define TPM_ECC_NIST_P224   (TPM_ECC_CURVE)(0x0002)
#define TPM_ECC_NIST_P256   (TPM_ECC_CURVE)(0x0003)
#define TPM_ECC_NIST_P384   (TPM_ECC_CURVE)(0x0004)
#define TPM_ECC_NIST_P521   (TPM_ECC_CURVE)(0x0005)
#define TPM_ECC_BN_P256     (TPM_ECC_CURVE)(0x0010)
#define TPM_ECC_BN_P638     (TPM_ECC_CURVE)(0x0011)
#define TPM_ECC_SM2_P256    (TPM_ECC_CURVE)(0x0020)

/* Table 2:12 - Definition of TPM_CC Constants */
typedef UINT32                              TPM_CC;
#define TYPE_OF_TPM_CC                      UINT32
#define TPM_CC_NV_UndefineSpaceSpecial      (TPM_CC)(0x0000011F)
#define TPM_CC_EvictControl                 (TPM_CC)(0x00000120)
#define TPM_CC_HierarchyControl             (TPM_CC)(0x00000121)
#define TPM_CC_NV_UndefineSpace             (TPM_CC)(0x00000122)
#define TPM_CC_ChangeEPS                    (TPM_CC)(0x00000124)
#define TPM_CC_ChangePPS                    (TPM_CC)(0x00000125)
#define TPM_CC_Clear                        (TPM_CC)(0x00000126)
#define TPM_CC_ClearControl                 (TPM_CC)(0x00000127)
#define TPM_CC_ClockSet                     (TPM_CC)(0x00000128)
#define TPM_CC_HierarchyChangeAuth          (TPM_CC)(0x00000129)
#define TPM_CC_NV_DefineSpace               (TPM_CC)(0x0000012A)
#define TPM_CC_PCR_Allocate                 (TPM_CC)(0x0000012B)
#define TPM_CC_PCR_SetAuthPolicy            (TPM_CC)(0x0000012C)
#define TPM_CC_PP_Commands                  (TPM_CC)(0x0000012D)
#define TPM_CC_SetPrimaryPolicy             (TPM_CC)(0x0000012E)
#define TPM_CC_FieldUpgradeStart            (TPM_CC)(0x0000012F)
#define TPM_CC_ClockRateAdjust              (TPM_CC)(0x00000130)
#define TPM_CC_CreatePrimary                (TPM_CC)(0x00000131)
#define TPM_CC_NV_GlobalWriteLock           (TPM_CC)(0x00000132)
#define TPM_CC_GetCommandAuditDigest        (TPM_CC)(0x00000133)
#define TPM_CC_NV_Increment                 (TPM_CC)(0x00000134)
#define TPM_CC_NV_SetBits                   (TPM_CC)(0x00000135)
#define TPM_CC_NV_Extend                    (TPM_CC)(0x00000136)
#define TPM_CC_NV_Write                     (TPM_CC)(0x00000137)
#define TPM_CC_NV_WriteLock                 (TPM_CC)(0x00000138)
#define TPM_CC_DictionaryAttackLockReset    (TPM_CC)(0x00000139)
#define TPM_CC_DictionaryAttackParameters   (TPM_CC)(0x0000013A)
#define TPM_CC_NV_ChangeAuth                (TPM_CC)(0x0000013B)
#define TPM_CC_PCR_Event                    (TPM_CC)(0x0000013C)
#define TPM_CC_PCR_Reset                    (TPM_CC)(0x0000013D)
#define TPM_CC_SequenceComplete             (TPM_CC)(0x0000013E)
#define TPM_CC_SetAlgorithmSet              (TPM_CC)(0x0000013F)
#define TPM_CC_SetCommandCodeAuditStatus    (TPM_CC)(0x00000140)
#define TPM_CC_FieldUpgradeData             (TPM_CC)(0x00000141)
#define TPM_CC_IncrementalSelfTest          (TPM_CC)(0x00000142)
#define TPM_CC_SelfTest                     (TPM_CC)(0x00000143)
#define TPM_CC_Startup                      (TPM_CC)(0x00000144)
#define TPM_CC_Shutdown                     (TPM_CC)(0x00000145)
#define TPM_CC_StirRandom                   (TPM_CC)(0x00000146)
#define TPM_CC_ActivateCredential           (TPM_CC)(0x00000147)
#define TPM_CC_Certify                      (TPM_CC)(0x00000148)
#define TPM_CC_PolicyNV                     (TPM_CC)(0x00000149)
#define TPM_CC_CertifyCreation              (TPM_CC)(0x0000014A)
#define TPM_CC_Duplicate                    (TPM_CC)(0x0000014B)
#define TPM_CC_GetTime                      (TPM_CC)(0x0000014C)
#define TPM_CC_GetSessionAuditDigest        (TPM_CC)(0x0000014D)
#define TPM_CC_NV_Read                      (TPM_CC)(0x0000014E)
#define TPM_CC_NV_ReadLock                  (TPM_CC)(0x0000014F)
#define TPM_CC_ObjectChangeAuth             (TPM_CC)(0x00000150)
#define TPM_CC_PolicySecret                 (TPM_CC)(0x00000151)
#define TPM_CC_Rewrap                       (TPM_CC)(0x00000152)
#define TPM_CC_Create                       (TPM_CC)(0x00000153)
#define TPM_CC_ECDH_ZGen                    (TPM_CC)(0x00000154)
#define TPM_CC_HMAC                         (TPM_CC)(0x00000155)
#define TPM_CC_MAC                          (TPM_CC)(0x00000155)
#define TPM_CC_Import                       (TPM_CC)(0x00000156)
#define TPM_CC_Load                         (TPM_CC)(0x00000157)
#define TPM_CC_Quote                        (TPM_CC)(0x00000158)
#define TPM_CC_RSA_Decrypt                  (TPM_CC)(0x00000159)
#define TPM_CC_HMAC_Start                   (TPM_CC)(0x0000015B)
#define TPM_CC_MAC_Start                    (TPM_CC)(0x0000015B)
#define TPM_CC_SequenceUpdate               (TPM_CC)(0x0000015C)
#define TPM_CC_Sign                         (TPM_CC)(0x0000015D)
#define TPM_CC_Unseal                       (TPM_CC)(0x0000015E)
#define TPM_CC_PolicySigned                 (TPM_CC)(0x00000160)
#define TPM_CC_ContextLoad                  (TPM_CC)(0x00000161)
#define TPM_CC_ContextSave                  (TPM_CC)(0x00000162)
#define TPM_CC_ECDH_KeyGen                  (TPM_CC)(0x00000163)
#define TPM_CC_EncryptDecrypt               (TPM_CC)(0x00000164)
#define TPM_CC_FlushContext                 (TPM_CC)(0x00000165)
#define TPM_CC_LoadExternal                 (TPM_CC)(0x00000167)
#define TPM_CC_MakeCredential               (TPM_CC)(0x00000168)
#define TPM_CC_NV_ReadPublic                (TPM_CC)(0x00000169)
#define TPM_CC_PolicyAuthorize              (TPM_CC)(0x0000016A)
#define TPM_CC_PolicyAuthValue              (TPM_CC)(0x0000016B)
#define TPM_CC_PolicyCommandCode            (TPM_CC)(0x0000016C)
#define TPM_CC_PolicyCounterTimer           (TPM_CC)(0x0000016D)
#define TPM_CC_PolicyCpHash                 (TPM_CC)(0x0000016E)
#define TPM_CC_PolicyLocality               (TPM_CC)(0x0000016F)
#define TPM_CC_PolicyNameHash               (TPM_CC)(0x00000170)
#define TPM_CC_PolicyOR                     (TPM_CC)(0x00000171)
#define TPM_CC_PolicyTicket                 (TPM_CC)(0x00000172)
#define TPM_CC_ReadPublic                   (TPM_CC)(0x00000173)
#define TPM_CC_RSA_Encrypt                  (TPM_CC)(0x00000174)
#define TPM_CC_StartAuthSession             (TPM_CC)(0x00000176)
#define TPM_CC_VerifySignature              (TPM_CC)(0x00000177)
#define TPM_CC_ECC_Parameters               (TPM_CC)(0x00000178)
#define TPM_CC_FirmwareRead                 (TPM_CC)(0x00000179)
#define TPM_CC_GetCapability                (TPM_CC)(0x0000017A)
#define TPM_CC_GetRandom                    (TPM_CC)(0x0000017B)
#define TPM_CC_GetTestResult                (TPM_CC)(0x0000017C)
#define TPM_CC_Hash                         (TPM_CC)(0x0000017D)
#define TPM_CC_PCR_Read                     (TPM_CC)(0x0000017E)
#define TPM_CC_PolicyPCR                    (TPM_CC)(0x0000017F)
#define TPM_CC_PolicyRestart                (TPM_CC)(0x00000180)
#define TPM_CC_ReadClock                    (TPM_CC)(0x00000181)
#define TPM_CC_PCR_Extend                   (TPM_CC)(0x00000182)
#define TPM_CC_PCR_SetAuthValue             (TPM_CC)(0x00000183)
#define TPM_CC_NV_Certify                   (TPM_CC)(0x00000184)
#define TPM_CC_EventSequenceComplete        (TPM_CC)(0x00000185)
#define TPM_CC_HashSequenceStart            (TPM_CC)(0x00000186)
#define TPM_CC_PolicyPhysicalPresence       (TPM_CC)(0x00000187)
#define TPM_CC_PolicyDuplicationSelect      (TPM_CC)(0x00000188)
#define TPM_CC_PolicyGetDigest              (TPM_CC)(0x00000189)
#define TPM_CC_TestParms                    (TPM_CC)(0x0000018A)
#define TPM_CC_Commit                       (TPM_CC)(0x0000018B)
#define TPM_CC_PolicyPassword               (TPM_CC)(0x0000018C)
#define TPM_CC_ZGen_2Phase                  (TPM_CC)(0x0000018D)
#define TPM_CC_EC_Ephemeral                 (TPM_CC)(0x0000018E)
#define TPM_CC_PolicyNvWritten              (TPM_CC)(0x0000018F)
#define TPM_CC_PolicyTemplate               (TPM_CC)(0x00000190)
#define TPM_CC_CreateLoaded                 (TPM_CC)(0x00000191)
#define TPM_CC_PolicyAuthorizeNV            (TPM_CC)(0x00000192)
#define TPM_CC_EncryptDecrypt2              (TPM_CC)(0x00000193)
#define TPM_CC_AC_GetCapability             (TPM_CC)(0x00000194)
#define TPM_CC_AC_Send                      (TPM_CC)(0x00000195)
#define TPM_CC_Policy_AC_SendSelect         (TPM_CC)(0x00000196)
#define TPM_CC_CertifyX509                  (TPM_CC)(0x00000197)
#define TPM_CC_ACT_SetTimeout               (TPM_CC)(0x00000198)
#define CC_VEND                             0x20000000
#define TPM_CC_Vendor_TCG_Test              (TPM_CC)(0x20000000)

#define NTC2_CC_PreConfig		    (TPM_CC)(0x20000211)
#define NTC2_CC_LockPreConfig               (TPM_CC)(0x20000212)
#define NTC2_CC_GetConfig                   (TPM_CC)(0x20000213)

/* Table 2:5 - Definition of Types for Documentation Clarity */
typedef UINT32              TPM_ALGORITHM_ID;
#define TYPE_OF_TPM_ALGORITHM_ID    UINT32
typedef UINT32              TPM_MODIFIER_INDICATOR;
#define TYPE_OF_TPM_MODIFIER_INDICATOR  UINT32
typedef UINT32              TPM_AUTHORIZATION_SIZE;
#define TYPE_OF_TPM_AUTHORIZATION_SIZE  UINT32
typedef UINT32              TPM_PARAMETER_SIZE;
#define TYPE_OF_TPM_PARAMETER_SIZE  UINT32
typedef UINT16              TPM_KEY_SIZE;
#define TYPE_OF_TPM_KEY_SIZE    UINT16
typedef UINT16              TPM_KEY_BITS;
#define TYPE_OF_TPM_KEY_BITS    UINT16

/* Table 2:6 - Definition of TPM_SPEC Constants */
typedef  UINT32             TPM_SPEC;
#define TYPE_OF_TPM_SPEC        UINT32
#define SPEC_FAMILY             0x322E3000
#define TPM_SPEC_FAMILY         (TPM_SPEC)(SPEC_FAMILY)
#define SPEC_LEVEL              00
#define TPM_SPEC_LEVEL          (TPM_SPEC)(SPEC_LEVEL)
#define SPEC_VERSION            159
#define TPM_SPEC_VERSION        (TPM_SPEC)(SPEC_VERSION)
#define SPEC_YEAR               2019
#define TPM_SPEC_YEAR           (TPM_SPEC)(SPEC_YEAR)
#define SPEC_DAY_OF_YEAR        312
#define TPM_SPEC_DAY_OF_YEAR    (TPM_SPEC)(SPEC_DAY_OF_YEAR)

/* Table 2:7 - Definition of TPM_GENERATED Constants */

typedef UINT32                  TPM_GENERATED;
#define TYPE_OF_TPM_GENERATED   UINT32
#define TPM_GENERATED_VALUE     (TPM_GENERATED)(0xFF544347)

/* Table 2:16 - Definition of TPM_RC Constants */
typedef UINT32             TPM_RC;
#define TYPE_OF_TPM_RC              UINT32
#define TPM_RC_SUCCESS              (TPM_RC)(0x000)
#define TPM_RC_BAD_TAG              (TPM_RC)(0x01E)
#define RC_VER1                     (TPM_RC)(0x100)
#define TPM_RC_INITIALIZE           (TPM_RC)(RC_VER1+0x000)
#define TPM_RC_FAILURE              (TPM_RC)(RC_VER1+0x001)
#define TPM_RC_SEQUENCE             (TPM_RC)(RC_VER1+0x003)
#define TPM_RC_PRIVATE              (TPM_RC)(RC_VER1+0x00B)
#define TPM_RC_HMAC                 (TPM_RC)(RC_VER1+0x019)
#define TPM_RC_DISABLED             (TPM_RC)(RC_VER1+0x020)
#define TPM_RC_EXCLUSIVE            (TPM_RC)(RC_VER1+0x021)
#define TPM_RC_AUTH_TYPE            (TPM_RC)(RC_VER1+0x024)
#define TPM_RC_AUTH_MISSING         (TPM_RC)(RC_VER1+0x025)
#define TPM_RC_POLICY               (TPM_RC)(RC_VER1+0x026)
#define TPM_RC_PCR                  (TPM_RC)(RC_VER1+0x027)
#define TPM_RC_PCR_CHANGED          (TPM_RC)(RC_VER1+0x028)
#define TPM_RC_UPGRADE              (TPM_RC)(RC_VER1+0x02D)
#define TPM_RC_TOO_MANY_CONTEXTS    (TPM_RC)(RC_VER1+0x02E)
#define TPM_RC_AUTH_UNAVAILABLE     (TPM_RC)(RC_VER1+0x02F)
#define TPM_RC_REBOOT               (TPM_RC)(RC_VER1+0x030)
#define TPM_RC_UNBALANCED           (TPM_RC)(RC_VER1+0x031)
#define TPM_RC_COMMAND_SIZE         (TPM_RC)(RC_VER1+0x042)
#define TPM_RC_COMMAND_CODE         (TPM_RC)(RC_VER1+0x043)
#define TPM_RC_AUTHSIZE             (TPM_RC)(RC_VER1+0x044)
#define TPM_RC_AUTH_CONTEXT         (TPM_RC)(RC_VER1+0x045)
#define TPM_RC_NV_RANGE             (TPM_RC)(RC_VER1+0x046)
#define TPM_RC_NV_SIZE              (TPM_RC)(RC_VER1+0x047)
#define TPM_RC_NV_LOCKED            (TPM_RC)(RC_VER1+0x048)
#define TPM_RC_NV_AUTHORIZATION     (TPM_RC)(RC_VER1+0x049)
#define TPM_RC_NV_UNINITIALIZED     (TPM_RC)(RC_VER1+0x04A)
#define TPM_RC_NV_SPACE             (TPM_RC)(RC_VER1+0x04B)
#define TPM_RC_NV_DEFINED           (TPM_RC)(RC_VER1+0x04C)
#define TPM_RC_BAD_CONTEXT          (TPM_RC)(RC_VER1+0x050)
#define TPM_RC_CPHASH               (TPM_RC)(RC_VER1+0x051)
#define TPM_RC_PARENT               (TPM_RC)(RC_VER1+0x052)
#define TPM_RC_NEEDS_TEST           (TPM_RC)(RC_VER1+0x053)
#define TPM_RC_NO_RESULT            (TPM_RC)(RC_VER1+0x054)
#define TPM_RC_SENSITIVE            (TPM_RC)(RC_VER1+0x055)
#define RC_MAX_FM0                  (TPM_RC)(RC_VER1+0x07F)
#define RC_FMT1                     (TPM_RC)(0x080)
#define TPM_RC_ASYMMETRIC           (TPM_RC)(RC_FMT1+0x001)
#define TPM_RCS_ASYMMETRIC          (TPM_RC)(RC_FMT1+0x001)
#define TPM_RC_ATTRIBUTES           (TPM_RC)(RC_FMT1+0x002)
#define TPM_RCS_ATTRIBUTES          (TPM_RC)(RC_FMT1+0x002)
#define TPM_RC_HASH                 (TPM_RC)(RC_FMT1+0x003)
#define TPM_RCS_HASH                (TPM_RC)(RC_FMT1+0x003)
#define TPM_RC_VALUE                (TPM_RC)(RC_FMT1+0x004)
#define TPM_RCS_VALUE               (TPM_RC)(RC_FMT1+0x004)
#define TPM_RC_HIERARCHY            (TPM_RC)(RC_FMT1+0x005)
#define TPM_RCS_HIERARCHY           (TPM_RC)(RC_FMT1+0x005)
#define TPM_RC_KEY_SIZE             (TPM_RC)(RC_FMT1+0x007)
#define TPM_RCS_KEY_SIZE            (TPM_RC)(RC_FMT1+0x007)
#define TPM_RC_MGF                  (TPM_RC)(RC_FMT1+0x008)
#define TPM_RCS_MGF                 (TPM_RC)(RC_FMT1+0x008)
#define TPM_RC_MODE                 (TPM_RC)(RC_FMT1+0x009)
#define TPM_RCS_MODE                (TPM_RC)(RC_FMT1+0x009)
#define TPM_RC_TYPE                 (TPM_RC)(RC_FMT1+0x00A)
#define TPM_RCS_TYPE                (TPM_RC)(RC_FMT1+0x00A)
#define TPM_RC_HANDLE               (TPM_RC)(RC_FMT1+0x00B)
#define TPM_RCS_HANDLE              (TPM_RC)(RC_FMT1+0x00B)
#define TPM_RC_KDF                  (TPM_RC)(RC_FMT1+0x00C)
#define TPM_RCS_KDF                 (TPM_RC)(RC_FMT1+0x00C)
#define TPM_RC_RANGE                (TPM_RC)(RC_FMT1+0x00D)
#define TPM_RCS_RANGE               (TPM_RC)(RC_FMT1+0x00D)
#define TPM_RC_AUTH_FAIL            (TPM_RC)(RC_FMT1+0x00E)
#define TPM_RCS_AUTH_FAIL           (TPM_RC)(RC_FMT1+0x00E)
#define TPM_RC_NONCE                (TPM_RC)(RC_FMT1+0x00F)
#define TPM_RCS_NONCE               (TPM_RC)(RC_FMT1+0x00F)
#define TPM_RC_PP                   (TPM_RC)(RC_FMT1+0x010)
#define TPM_RCS_PP                  (TPM_RC)(RC_FMT1+0x010)
#define TPM_RC_SCHEME               (TPM_RC)(RC_FMT1+0x012)
#define TPM_RCS_SCHEME              (TPM_RC)(RC_FMT1+0x012)
#define TPM_RC_SIZE                 (TPM_RC)(RC_FMT1+0x015)
#define TPM_RCS_SIZE                (TPM_RC)(RC_FMT1+0x015)
#define TPM_RC_SYMMETRIC            (TPM_RC)(RC_FMT1+0x016)
#define TPM_RCS_SYMMETRIC           (TPM_RC)(RC_FMT1+0x016)
#define TPM_RC_TAG                  (TPM_RC)(RC_FMT1+0x017)
#define TPM_RCS_TAG                 (TPM_RC)(RC_FMT1+0x017)
#define TPM_RC_SELECTOR             (TPM_RC)(RC_FMT1+0x018)
#define TPM_RCS_SELECTOR            (TPM_RC)(RC_FMT1+0x018)
#define TPM_RC_INSUFFICIENT         (TPM_RC)(RC_FMT1+0x01A)
#define TPM_RCS_INSUFFICIENT        (TPM_RC)(RC_FMT1+0x01A)
#define TPM_RC_SIGNATURE            (TPM_RC)(RC_FMT1+0x01B)
#define TPM_RCS_SIGNATURE           (TPM_RC)(RC_FMT1+0x01B)
#define TPM_RC_KEY                  (TPM_RC)(RC_FMT1+0x01C)
#define TPM_RCS_KEY                 (TPM_RC)(RC_FMT1+0x01C)
#define TPM_RC_POLICY_FAIL          (TPM_RC)(RC_FMT1+0x01D)
#define TPM_RCS_POLICY_FAIL         (TPM_RC)(RC_FMT1+0x01D)
#define TPM_RC_INTEGRITY            (TPM_RC)(RC_FMT1+0x01F)
#define TPM_RCS_INTEGRITY           (TPM_RC)(RC_FMT1+0x01F)
#define TPM_RC_TICKET               (TPM_RC)(RC_FMT1+0x020)
#define TPM_RCS_TICKET              (TPM_RC)(RC_FMT1+0x020)
#define TPM_RC_RESERVED_BITS        (TPM_RC)(RC_FMT1+0x021)
#define TPM_RCS_RESERVED_BITS       (TPM_RC)(RC_FMT1+0x021)
#define TPM_RC_BAD_AUTH             (TPM_RC)(RC_FMT1+0x022)
#define TPM_RCS_BAD_AUTH            (TPM_RC)(RC_FMT1+0x022)
#define TPM_RC_EXPIRED              (TPM_RC)(RC_FMT1+0x023)
#define TPM_RCS_EXPIRED             (TPM_RC)(RC_FMT1+0x023)
#define TPM_RC_POLICY_CC            (TPM_RC)(RC_FMT1+0x024)
#define TPM_RCS_POLICY_CC           (TPM_RC)(RC_FMT1+0x024)
#define TPM_RC_BINDING              (TPM_RC)(RC_FMT1+0x025)
#define TPM_RCS_BINDING             (TPM_RC)(RC_FMT1+0x025)
#define TPM_RC_CURVE                (TPM_RC)(RC_FMT1+0x026)
#define TPM_RCS_CURVE               (TPM_RC)(RC_FMT1+0x026)
#define TPM_RC_ECC_POINT            (TPM_RC)(RC_FMT1+0x027)
#define TPM_RCS_ECC_POINT           (TPM_RC)(RC_FMT1+0x027)
#define RC_WARN                     (TPM_RC)(0x900)
#define TPM_RC_CONTEXT_GAP          (TPM_RC)(RC_WARN+0x001)
#define TPM_RC_OBJECT_MEMORY        (TPM_RC)(RC_WARN+0x002)
#define TPM_RC_SESSION_MEMORY       (TPM_RC)(RC_WARN+0x003)
#define TPM_RC_MEMORY               (TPM_RC)(RC_WARN+0x004)
#define TPM_RC_SESSION_HANDLES      (TPM_RC)(RC_WARN+0x005)
#define TPM_RC_OBJECT_HANDLES       (TPM_RC)(RC_WARN+0x006)
#define TPM_RC_LOCALITY             (TPM_RC)(RC_WARN+0x007)
#define TPM_RC_YIELDED              (TPM_RC)(RC_WARN+0x008)
#define TPM_RC_CANCELED             (TPM_RC)(RC_WARN+0x009)
#define TPM_RC_TESTING              (TPM_RC)(RC_WARN+0x00A)
#define TPM_RC_REFERENCE_H0         (TPM_RC)(RC_WARN+0x010)
#define TPM_RC_REFERENCE_H1         (TPM_RC)(RC_WARN+0x011)
#define TPM_RC_REFERENCE_H2         (TPM_RC)(RC_WARN+0x012)
#define TPM_RC_REFERENCE_H3         (TPM_RC)(RC_WARN+0x013)
#define TPM_RC_REFERENCE_H4         (TPM_RC)(RC_WARN+0x014)
#define TPM_RC_REFERENCE_H5         (TPM_RC)(RC_WARN+0x015)
#define TPM_RC_REFERENCE_H6         (TPM_RC)(RC_WARN+0x016)
#define TPM_RC_REFERENCE_S0         (TPM_RC)(RC_WARN+0x018)
#define TPM_RC_REFERENCE_S1         (TPM_RC)(RC_WARN+0x019)
#define TPM_RC_REFERENCE_S2         (TPM_RC)(RC_WARN+0x01A)
#define TPM_RC_REFERENCE_S3         (TPM_RC)(RC_WARN+0x01B)
#define TPM_RC_REFERENCE_S4         (TPM_RC)(RC_WARN+0x01C)
#define TPM_RC_REFERENCE_S5         (TPM_RC)(RC_WARN+0x01D)
#define TPM_RC_REFERENCE_S6         (TPM_RC)(RC_WARN+0x01E)
#define TPM_RC_NV_RATE              (TPM_RC)(RC_WARN+0x020)
#define TPM_RC_LOCKOUT              (TPM_RC)(RC_WARN+0x021)
#define TPM_RC_RETRY                (TPM_RC)(RC_WARN+0x022)
#define TPM_RC_NV_UNAVAILABLE       (TPM_RC)(RC_WARN+0x023)
#define TPM_RC_NOT_USED             (TPM_RC)(RC_WARN+0x7F)
#define TPM_RC_H                    (TPM_RC)(0x000)
#define TPM_RC_P                    (TPM_RC)(0x040)
#define TPM_RC_S                    (TPM_RC)(0x800)
#define TPM_RC_1                    (TPM_RC)(0x100)
#define TPM_RC_2                    (TPM_RC)(0x200)
#define TPM_RC_3                    (TPM_RC)(0x300)
#define TPM_RC_4                    (TPM_RC)(0x400)
#define TPM_RC_5                    (TPM_RC)(0x500)
#define TPM_RC_6                    (TPM_RC)(0x600)
#define TPM_RC_7                    (TPM_RC)(0x700)
#define TPM_RC_8                    (TPM_RC)(0x800)
#define TPM_RC_9                    (TPM_RC)(0x900)
#define TPM_RC_A                    (TPM_RC)(0xA00)
#define TPM_RC_B                    (TPM_RC)(0xB00)
#define TPM_RC_C                    (TPM_RC)(0xC00)
#define TPM_RC_D                    (TPM_RC)(0xD00)
#define TPM_RC_E                    (TPM_RC)(0xE00)
#define TPM_RC_F                    (TPM_RC)(0xF00)
#define TPM_RC_N_MASK               (TPM_RC)(0xF00)

/* Table 2:17 - Definition of TPM_CLOCK_ADJUST Constants */
typedef BYTE               TPM_CLOCK_ADJUST;
#define TYPE_OF_TPM_CLOCK_ADJUST    BYTE
#define TPM_CLOCK_COARSE_SLOWER    (TPM_CLOCK_ADJUST)(-3)
#define TPM_CLOCK_MEDIUM_SLOWER    (TPM_CLOCK_ADJUST)(-2)
#define TPM_CLOCK_FINE_SLOWER      (TPM_CLOCK_ADJUST)(-1)
#define TPM_CLOCK_NO_CHANGE        (TPM_CLOCK_ADJUST)(0)
#define TPM_CLOCK_FINE_FASTER      (TPM_CLOCK_ADJUST)(1)
#define TPM_CLOCK_MEDIUM_FASTER    (TPM_CLOCK_ADJUST)(2)
#define TPM_CLOCK_COARSE_FASTER    (TPM_CLOCK_ADJUST)(3)

/* Table 2:18 - Definition of TPM_EO Constants */
typedef  UINT16             TPM_EO;
#define TYPE_OF_TPM_EO      UINT16
#define TPM_EO_EQ             (TPM_EO)(0x0000)
#define TPM_EO_NEQ            (TPM_EO)(0x0001)
#define TPM_EO_SIGNED_GT      (TPM_EO)(0x0002)
#define TPM_EO_UNSIGNED_GT    (TPM_EO)(0x0003)
#define TPM_EO_SIGNED_LT      (TPM_EO)(0x0004)
#define TPM_EO_UNSIGNED_LT    (TPM_EO)(0x0005)
#define TPM_EO_SIGNED_GE      (TPM_EO)(0x0006)
#define TPM_EO_UNSIGNED_GE    (TPM_EO)(0x0007)
#define TPM_EO_SIGNED_LE      (TPM_EO)(0x0008)
#define TPM_EO_UNSIGNED_LE    (TPM_EO)(0x0009)
#define TPM_EO_BITSET         (TPM_EO)(0x000A)
#define TPM_EO_BITCLEAR       (TPM_EO)(0x000B)
/* Table 2:19 - Definition of TPM_ST Constants */

typedef  UINT16             TPM_ST;
#define TYPE_OF_TPM_ST                  UINT16
#define TPM_ST_RSP_COMMAND             (TPM_ST)(0x00C4)
#define TPM_ST_NULL                    (TPM_ST)(0x8000)
#define TPM_ST_NO_SESSIONS             (TPM_ST)(0x8001)
#define TPM_ST_SESSIONS                (TPM_ST)(0x8002)
#define TPM_ST_ATTEST_NV               (TPM_ST)(0x8014)
#define TPM_ST_ATTEST_COMMAND_AUDIT    (TPM_ST)(0x8015)
#define TPM_ST_ATTEST_SESSION_AUDIT    (TPM_ST)(0x8016)
#define TPM_ST_ATTEST_CERTIFY          (TPM_ST)(0x8017)
#define TPM_ST_ATTEST_QUOTE            (TPM_ST)(0x8018)
#define TPM_ST_ATTEST_TIME             (TPM_ST)(0x8019)
#define TPM_ST_ATTEST_CREATION         (TPM_ST)(0x801A)
#define TPM_ST_ATTEST_NV_DIGEST	       (TPM_ST)(0x801C)
#define TPM_ST_CREATION                (TPM_ST)(0x8021)
#define TPM_ST_VERIFIED                (TPM_ST)(0x8022)
#define TPM_ST_AUTH_SECRET             (TPM_ST)(0x8023)
#define TPM_ST_HASHCHECK               (TPM_ST)(0x8024)
#define TPM_ST_AUTH_SIGNED             (TPM_ST)(0x8025)
#define TPM_ST_FU_MANIFEST             (TPM_ST)(0x8029)

/* Table 2:20 - Definition of TPM_SU Constants */
typedef UINT16             TPM_SU;
#define TYPE_OF_TPM_SU      UINT16
#define TPM_SU_CLEAR    (TPM_SU)(0x0000)
#define TPM_SU_STATE    (TPM_SU)(0x0001)

/* Table 2:21 - Definition of TPM_SE Constants */
typedef BYTE              TPM_SE;
#define TYPE_OF_TPM_SE      BYTE
#define TPM_SE_HMAC      (TPM_SE)(0x00)
#define TPM_SE_POLICY    (TPM_SE)(0x01)
#define TPM_SE_TRIAL     (TPM_SE)(0x03)

/* Table 2:22 - Definition of TPM_CAP Constants */
typedef UINT32             TPM_CAP;
#define TYPE_OF_TPM_CAP             UINT32
#define TPM_CAP_FIRST              (TPM_CAP)(0x00000000)
#define TPM_CAP_ALGS               (TPM_CAP)(0x00000000)
#define TPM_CAP_HANDLES            (TPM_CAP)(0x00000001)
#define TPM_CAP_COMMANDS           (TPM_CAP)(0x00000002)
#define TPM_CAP_PP_COMMANDS        (TPM_CAP)(0x00000003)
#define TPM_CAP_AUDIT_COMMANDS     (TPM_CAP)(0x00000004)
#define TPM_CAP_PCRS               (TPM_CAP)(0x00000005)
#define TPM_CAP_TPM_PROPERTIES     (TPM_CAP)(0x00000006)
#define TPM_CAP_PCR_PROPERTIES     (TPM_CAP)(0x00000007)
#define TPM_CAP_ECC_CURVES         (TPM_CAP)(0x00000008)
#define TPM_CAP_AUTH_POLICIES      (TPM_CAP)(0x00000009)
#define TPM_CAP_ACT 		   (TPM_CAP)(0x0000000a)
#define TPM_CAP_LAST               (TPM_CAP)(0x0000000a)
#define TPM_CAP_VENDOR_PROPERTY    (TPM_CAP)(0x00000100)

/* Table 2:23 - Definition of TPM_PT Constants */
typedef  UINT32             TPM_PT;
#define TYPE_OF_TPM_PT              UINT32
#define TPM_PT_NONE                   (TPM_PT)(0x00000000)
#define PT_GROUP                      (TPM_PT)(0x00000100)
#define PT_FIXED                      (TPM_PT)(PT_GROUP*1)
#define TPM_PT_FAMILY_INDICATOR       (TPM_PT)(PT_FIXED+0)
#define TPM_PT_LEVEL                  (TPM_PT)(PT_FIXED+1)
#define TPM_PT_REVISION               (TPM_PT)(PT_FIXED+2)
#define TPM_PT_DAY_OF_YEAR            (TPM_PT)(PT_FIXED+3)
#define TPM_PT_YEAR                   (TPM_PT)(PT_FIXED+4)
#define TPM_PT_MANUFACTURER           (TPM_PT)(PT_FIXED+5)
#define TPM_PT_VENDOR_STRING_1        (TPM_PT)(PT_FIXED+6)
#define TPM_PT_VENDOR_STRING_2        (TPM_PT)(PT_FIXED+7)
#define TPM_PT_VENDOR_STRING_3        (TPM_PT)(PT_FIXED+8)
#define TPM_PT_VENDOR_STRING_4        (TPM_PT)(PT_FIXED+9)
#define TPM_PT_VENDOR_TPM_TYPE        (TPM_PT)(PT_FIXED+10)
#define TPM_PT_FIRMWARE_VERSION_1     (TPM_PT)(PT_FIXED+11)
#define TPM_PT_FIRMWARE_VERSION_2     (TPM_PT)(PT_FIXED+12)
#define TPM_PT_INPUT_BUFFER           (TPM_PT)(PT_FIXED+13)
#define TPM_PT_HR_TRANSIENT_MIN       (TPM_PT)(PT_FIXED+14)
#define TPM_PT_HR_PERSISTENT_MIN      (TPM_PT)(PT_FIXED+15)
#define TPM_PT_HR_LOADED_MIN          (TPM_PT)(PT_FIXED+16)
#define TPM_PT_ACTIVE_SESSIONS_MAX    (TPM_PT)(PT_FIXED+17)
#define TPM_PT_PCR_COUNT              (TPM_PT)(PT_FIXED+18)
#define TPM_PT_PCR_SELECT_MIN         (TPM_PT)(PT_FIXED+19)
#define TPM_PT_CONTEXT_GAP_MAX        (TPM_PT)(PT_FIXED+20)
#define TPM_PT_NV_COUNTERS_MAX        (TPM_PT)(PT_FIXED+22)
#define TPM_PT_NV_INDEX_MAX           (TPM_PT)(PT_FIXED+23)
#define TPM_PT_MEMORY                 (TPM_PT)(PT_FIXED+24)
#define TPM_PT_CLOCK_UPDATE           (TPM_PT)(PT_FIXED+25)
#define TPM_PT_CONTEXT_HASH           (TPM_PT)(PT_FIXED+26)
#define TPM_PT_CONTEXT_SYM            (TPM_PT)(PT_FIXED+27)
#define TPM_PT_CONTEXT_SYM_SIZE       (TPM_PT)(PT_FIXED+28)
#define TPM_PT_ORDERLY_COUNT          (TPM_PT)(PT_FIXED+29)
#define TPM_PT_MAX_COMMAND_SIZE       (TPM_PT)(PT_FIXED+30)
#define TPM_PT_MAX_RESPONSE_SIZE      (TPM_PT)(PT_FIXED+31)
#define TPM_PT_MAX_DIGEST             (TPM_PT)(PT_FIXED+32)
#define TPM_PT_MAX_OBJECT_CONTEXT     (TPM_PT)(PT_FIXED+33)
#define TPM_PT_MAX_SESSION_CONTEXT    (TPM_PT)(PT_FIXED+34)
#define TPM_PT_PS_FAMILY_INDICATOR    (TPM_PT)(PT_FIXED+35)
#define TPM_PT_PS_LEVEL               (TPM_PT)(PT_FIXED+36)
#define TPM_PT_PS_REVISION            (TPM_PT)(PT_FIXED+37)
#define TPM_PT_PS_DAY_OF_YEAR         (TPM_PT)(PT_FIXED+38)
#define TPM_PT_PS_YEAR                (TPM_PT)(PT_FIXED+39)
#define TPM_PT_SPLIT_MAX              (TPM_PT)(PT_FIXED+40)
#define TPM_PT_TOTAL_COMMANDS         (TPM_PT)(PT_FIXED+41)
#define TPM_PT_LIBRARY_COMMANDS       (TPM_PT)(PT_FIXED+42)
#define TPM_PT_VENDOR_COMMANDS        (TPM_PT)(PT_FIXED+43)
#define TPM_PT_NV_BUFFER_MAX          (TPM_PT)(PT_FIXED+44)
#define TPM_PT_MODES                  (TPM_PT)(PT_FIXED+45)
#define TPM_PT_MAX_CAP_BUFFER         (TPM_PT)(PT_FIXED+46)
#define PT_VAR                        (TPM_PT)(PT_GROUP*2)
#define TPM_PT_PERMANENT              (TPM_PT)(PT_VAR+0)
#define TPM_PT_STARTUP_CLEAR          (TPM_PT)(PT_VAR+1)
#define TPM_PT_HR_NV_INDEX            (TPM_PT)(PT_VAR+2)
#define TPM_PT_HR_LOADED              (TPM_PT)(PT_VAR+3)
#define TPM_PT_HR_LOADED_AVAIL        (TPM_PT)(PT_VAR+4)
#define TPM_PT_HR_ACTIVE              (TPM_PT)(PT_VAR+5)
#define TPM_PT_HR_ACTIVE_AVAIL        (TPM_PT)(PT_VAR+6)
#define TPM_PT_HR_TRANSIENT_AVAIL     (TPM_PT)(PT_VAR+7)
#define TPM_PT_HR_PERSISTENT          (TPM_PT)(PT_VAR+8)
#define TPM_PT_HR_PERSISTENT_AVAIL    (TPM_PT)(PT_VAR+9)
#define TPM_PT_NV_COUNTERS            (TPM_PT)(PT_VAR+10)
#define TPM_PT_NV_COUNTERS_AVAIL      (TPM_PT)(PT_VAR+11)
#define TPM_PT_ALGORITHM_SET          (TPM_PT)(PT_VAR+12)
#define TPM_PT_LOADED_CURVES          (TPM_PT)(PT_VAR+13)
#define TPM_PT_LOCKOUT_COUNTER        (TPM_PT)(PT_VAR+14)
#define TPM_PT_MAX_AUTH_FAIL          (TPM_PT)(PT_VAR+15)
#define TPM_PT_LOCKOUT_INTERVAL       (TPM_PT)(PT_VAR+16)
#define TPM_PT_LOCKOUT_RECOVERY       (TPM_PT)(PT_VAR+17)
#define TPM_PT_NV_WRITE_RECOVERY      (TPM_PT)(PT_VAR+18)
#define TPM_PT_AUDIT_COUNTER_0        (TPM_PT)(PT_VAR+19)
#define TPM_PT_AUDIT_COUNTER_1        (TPM_PT)(PT_VAR+20)

/* Table 2:24 - Definition of TPM_PT_PCR Constants */
typedef UINT32             TPM_PT_PCR;
#define TYPE_OF_TPM_PT_PCR          UINT32
#define TPM_PT_PCR_FIRST           (TPM_PT_PCR)(0x00000000)
#define TPM_PT_PCR_SAVE            (TPM_PT_PCR)(0x00000000)
#define TPM_PT_PCR_EXTEND_L0       (TPM_PT_PCR)(0x00000001)
#define TPM_PT_PCR_RESET_L0        (TPM_PT_PCR)(0x00000002)
#define TPM_PT_PCR_EXTEND_L1       (TPM_PT_PCR)(0x00000003)
#define TPM_PT_PCR_RESET_L1        (TPM_PT_PCR)(0x00000004)
#define TPM_PT_PCR_EXTEND_L2       (TPM_PT_PCR)(0x00000005)
#define TPM_PT_PCR_RESET_L2        (TPM_PT_PCR)(0x00000006)
#define TPM_PT_PCR_EXTEND_L3       (TPM_PT_PCR)(0x00000007)
#define TPM_PT_PCR_RESET_L3        (TPM_PT_PCR)(0x00000008)
#define TPM_PT_PCR_EXTEND_L4       (TPM_PT_PCR)(0x00000009)
#define TPM_PT_PCR_RESET_L4        (TPM_PT_PCR)(0x0000000A)
#define TPM_PT_PCR_NO_INCREMENT    (TPM_PT_PCR)(0x00000011)
#define TPM_PT_PCR_DRTM_RESET      (TPM_PT_PCR)(0x00000012)
#define TPM_PT_PCR_POLICY          (TPM_PT_PCR)(0x00000013)
#define TPM_PT_PCR_AUTH            (TPM_PT_PCR)(0x00000014)
#define TPM_PT_PCR_LAST            (TPM_PT_PCR)(0x00000014)

/* Table 2:25 - Definition of TPM_PS Constants  */
typedef UINT32             TPM_PS;
#define TYPE_OF_TPM_PS          UINT32
#define TPM_PS_MAIN              (TPM_PS)(0x00000000)
#define TPM_PS_PC                (TPM_PS)(0x00000001)
#define TPM_PS_PDA               (TPM_PS)(0x00000002)
#define TPM_PS_CELL_PHONE        (TPM_PS)(0x00000003)
#define TPM_PS_SERVER            (TPM_PS)(0x00000004)
#define TPM_PS_PERIPHERAL        (TPM_PS)(0x00000005)
#define TPM_PS_TSS               (TPM_PS)(0x00000006)
#define TPM_PS_STORAGE           (TPM_PS)(0x00000007)
#define TPM_PS_AUTHENTICATION    (TPM_PS)(0x00000008)
#define TPM_PS_EMBEDDED          (TPM_PS)(0x00000009)
#define TPM_PS_HARDCOPY          (TPM_PS)(0x0000000A)
#define TPM_PS_INFRASTRUCTURE    (TPM_PS)(0x0000000B)
#define TPM_PS_VIRTUALIZATION    (TPM_PS)(0x0000000C)
#define TPM_PS_TNC               (TPM_PS)(0x0000000D)
#define TPM_PS_MULTI_TENANT      (TPM_PS)(0x0000000E)
#define TPM_PS_TC                (TPM_PS)(0x0000000F)

/* Table 2:26 - Definition of Types for Handles */
typedef UINT32             TPM_HANDLE;
#define TYPE_OF_TPM_HANDLE  UINT32

/* Table 2:27 - Definition of TPM_HT Constants  */
typedef BYTE              TPM_HT;
#define TYPE_OF_TPM_HT          BYTE
#define TPM_HT_PCR               (TPM_HT)(0x00)
#define TPM_HT_NV_INDEX          (TPM_HT)(0x01)
#define TPM_HT_HMAC_SESSION      (TPM_HT)(0x02)
#define TPM_HT_LOADED_SESSION    (TPM_HT)(0x02)
#define TPM_HT_POLICY_SESSION    (TPM_HT)(0x03)
#define TPM_HT_SAVED_SESSION     (TPM_HT)(0x03)
#define TPM_HT_PERMANENT         (TPM_HT)(0x40)
#define TPM_HT_TRANSIENT         (TPM_HT)(0x80)
#define TPM_HT_PERSISTENT        (TPM_HT)(0x81)
#define TPM_HT_AC                (TPM_HT)(0x90)

/* Table 2:28 - Definition of TPM_RH Constants  */
typedef  TPM_HANDLE         TPM_RH;
#define  TPM_RH_FIRST          (TPM_RH)(0x40000000)
#define  TPM_RH_SRK            (TPM_RH)(0x40000000)
#define  TPM_RH_OWNER          (TPM_RH)(0x40000001)
#define  TPM_RH_REVOKE         (TPM_RH)(0x40000002)
#define  TPM_RH_TRANSPORT      (TPM_RH)(0x40000003)
#define  TPM_RH_OPERATOR       (TPM_RH)(0x40000004)
#define  TPM_RH_ADMIN          (TPM_RH)(0x40000005)
#define  TPM_RH_EK             (TPM_RH)(0x40000006)
#define  TPM_RH_NULL           (TPM_RH)(0x40000007)
#define  TPM_RH_UNASSIGNED     (TPM_RH)(0x40000008)
#define  TPM_RS_PW             (TPM_RH)(0x40000009)
#define  TPM_RH_LOCKOUT        (TPM_RH)(0x4000000A)
#define  TPM_RH_ENDORSEMENT    (TPM_RH)(0x4000000B)
#define  TPM_RH_PLATFORM       (TPM_RH)(0x4000000C)
#define  TPM_RH_PLATFORM_NV    (TPM_RH)(0x4000000D)
#define  TPM_RH_AUTH_00        (TPM_RH)(0x40000010)
#define  TPM_RH_AUTH_FF        (TPM_RH)(0x4000010F)
#define  TPM_RH_ACT_0          (TPM_RH)(0x40000110)
#define  TPM_RH_ACT_F          (TPM_RH)(0x4000011F)
#define  TPM_RH_LAST           (TPM_RH)(0x4000011F)
/* Table 2:29 - Definition of TPM_HC Constants  */
typedef  TPM_HANDLE         TPM_HC;
#define  HR_HANDLE_MASK          (TPM_HC)(0x00FFFFFF)
#define  HR_RANGE_MASK           (TPM_HC)(0xFF000000)
#define  HR_SHIFT                (TPM_HC)(24)
#define  HR_PCR                  (TPM_HC)((TPM_HT_PCR<<HR_SHIFT))
#define  HR_HMAC_SESSION         (TPM_HC)((TPM_HT_HMAC_SESSION<<HR_SHIFT))
#define  HR_POLICY_SESSION       (TPM_HC)((TPM_HT_POLICY_SESSION<<HR_SHIFT))

#define  HR_TRANSIENT		 (TPM_HC)((((UINT32)TPM_HT_TRANSIENT) << HR_SHIFT))
#define  HR_PERSISTENT           (TPM_HC)((((UINT32)TPM_HT_PERSISTENT) << HR_SHIFT))

#if 0
#define  HR_TRANSIENT            (TPM_HC)((TPM_HT_TRANSIENT<<HR_SHIFT))
#define  HR_PERSISTENT           (TPM_HC)((TPM_HT_PERSISTENT<<HR_SHIFT))
#endif

#define  HR_NV_INDEX             (TPM_HC)((TPM_HT_NV_INDEX<<HR_SHIFT))
#define  HR_PERMANENT            (TPM_HC)((TPM_HT_PERMANENT<<HR_SHIFT))
#define  PCR_FIRST               (TPM_HC)((HR_PCR+0))
#define  PCR_LAST                (TPM_HC)((PCR_FIRST+IMPLEMENTATION_PCR-1))
#define  HMAC_SESSION_FIRST      (TPM_HC)((HR_HMAC_SESSION+0))
#define  HMAC_SESSION_LAST       (TPM_HC)((HMAC_SESSION_FIRST + MAX_ACTIVE_SESSIONS-1))
#define  LOADED_SESSION_FIRST    (TPM_HC)(HMAC_SESSION_FIRST)
#define  LOADED_SESSION_LAST     (TPM_HC)(HMAC_SESSION_LAST)
#define  POLICY_SESSION_FIRST    (TPM_HC)((HR_POLICY_SESSION+0))
#define  POLICY_SESSION_LAST	 (TPM_HC)((POLICY_SESSION_FIRST + MAX_ACTIVE_SESSIONS-1))
#define  TRANSIENT_FIRST         (TPM_HC)((HR_TRANSIENT+0))
#define  ACTIVE_SESSION_FIRST    (TPM_HC)(POLICY_SESSION_FIRST)
#define  ACTIVE_SESSION_LAST     (TPM_HC)(POLICY_SESSION_LAST)
#define  TRANSIENT_LAST          (TPM_HC)((TRANSIENT_FIRST+MAX_LOADED_OBJECTS-1))
#define  PERSISTENT_FIRST        (TPM_HC)((HR_PERSISTENT+0))
#define  PERSISTENT_LAST         (TPM_HC)((PERSISTENT_FIRST+0x00FFFFFF))
#define  PLATFORM_PERSISTENT     (TPM_HC)((PERSISTENT_FIRST+0x00800000))
#define  NV_INDEX_FIRST          (TPM_HC)((HR_NV_INDEX+0))
#define  NV_INDEX_LAST           (TPM_HC)((NV_INDEX_FIRST+0x00FFFFFF))
#define  PERMANENT_FIRST         (TPM_HC)(TPM_RH_FIRST)
#define  PERMANENT_LAST          (TPM_HC)(TPM_RH_LAST)
#define  HR_NV_AC                (TPM_HC)(((TPM_HT_NV_INDEX<<HR_SHIFT)+0xD00000))
#define  NV_AC_FIRST             (TPM_HC)((HR_NV_AC+0))
#define  NV_AC_LAST              (TPM_HC)((HR_NV_AC+0x0000FFFF))
#define  HR_AC                   (TPM_HC)((TPM_HT_AC<<HR_SHIFT))
#define  AC_FIRST                (TPM_HC)((HR_AC+0))
#define  AC_LAST                 (TPM_HC)((HR_AC+0x0000FFFF))

#define TYPE_OF_TPMA_ALGORITHM  UINT32
#define TPMA_ALGORITHM_TO_UINT32(a)  (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_ALGORITHM(a)  (*((TPMA_ALGORITHM *)&(a)))

/* The aggregation macros for machines that do not allow unaligned access or for little-endian
   machines. Aggregate bytes into an UINT */
#define BYTE_ARRAY_TO_UINT8(b)  (uint8_t)((b)[0])
#define BYTE_ARRAY_TO_UINT16(b) ByteArrayToUint16((BYTE *)(b))
#define BYTE_ARRAY_TO_UINT32(b) ByteArrayToUint32((BYTE *)(b))
#define BYTE_ARRAY_TO_UINT64(b) ByteArrayToUint64((BYTE *)(b))
#define UINT8_TO_BYTE_ARRAY(i, b) ((b)[0] = (uint8_t)(i))
#define UINT16_TO_BYTE_ARRAY(i, b)  UINT16ToArray((i), (BYTE *)(b))
#define UINT32_TO_BYTE_ARRAY(i, b)  UINT32ToArray((i), (BYTE *)(b))
#define UINT64_TO_BYTE_ARRAY(i, b)  UINT64ToArray((i), (BYTE *)(b))

#define TPMA_ALGORITHM_TO_BYTE_ARRAY(i, a)				\
	            UINT32_TO_BYTE_ARRAY((TPMA_ALGORITHM_TO_UINT32(i)), (a))

#define BYTE_ARRAY_TO_TPMA_ALGORITHM(i, a)				\
    {UINT32 x = BYTE_ARRAY_TO_UINT32(a);				\
	i = UINT32_TO_TPMA_ALGORITHM(x);				\
    }

/* Table 2:30 - Definition of TPMA_ALGORITHM Bits */
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_ALGORITHM{
    unsigned    asymmetric           : 1 ;
    unsigned    symmetric            : 1 ;
    unsigned    hash                 : 1 ;
    unsigned    object               : 1 ;
    unsigned    Reserved_bits_at_4   : 4 ;
    unsigned    signing              : 1 ;
    unsigned    encrypting           : 1 ;
    unsigned    method               : 1 ;
    unsigned    Reserved_bits_at_11  : 21;
} __attribute__((packed)) TPMA_ALGORITHM;
/* This is the initializer for a TPMA_ALGORITHM structure. */
#define TPMA_ALGORITHM_INITIALIZER(					\
				   asymmetric, symmetric,  hash,       object,     bits_at_4, \
				   signing,    encrypting, method,     bits_at_11) \
    {asymmetric, symmetric,  hash,       object,     bits_at_4,		\
	    signing,    encrypting, method,     bits_at_11}
#else // USE_BIT_FIELD_STRUCTURES

typedef UINT32 TPMA_ALGORITHM;
#define TYPE_OF_TPMA_ALGORITHM      UINT32
#define TPMA_ALGORITHM_asymmetric        ((TPMA_ALGORITHM)1 << 0)
#define TPMA_ALGORITHM_symmetric         ((TPMA_ALGORITHM)1 << 1)
#define TPMA_ALGORITHM_hash              ((TPMA_ALGORITHM)1 << 2)
#define TPMA_ALGORITHM_object            ((TPMA_ALGORITHM)1 << 3)
#define TPMA_ALGORITHM_signing           ((TPMA_ALGORITHM)1 << 8)
#define TPMA_ALGORITHM_encrypting        ((TPMA_ALGORITHM)1 << 9)
#define TPMA_ALGORITHM_method            ((TPMA_ALGORITHM)1 << 10)
#define TPMA_ALGORITHM_reserved		 0xfffff8f0

#define TPMA_ALGORITHM_INITIALIZER(					\
				   asymmetric, symmetric,  hash,       object,     bits_at_4, \
				   signing,    encrypting, method,     bits_at_11) \
    (asymmetric << 0) + (symmetric << 1)  + (hash << 2)       +	\
	    (object << 3)     + (signing << 8)    + (encrypting << 9) +	\
	    (method << 10)
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_OBJECT UINT32
#define TPMA_OBJECT_TO_UINT32(a)     (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_OBJECT(a)     (*((TPMA_OBJECT *)&(a)))
#define TPMA_OBJECT_TO_BYTE_ARRAY(i, a)				\
    UINT32_TO_BYTE_ARRAY((TPMA_OBJECT_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_OBJECT(i, a)					\
    { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_OBJECT(x); }

/* This is the initializer for a TPMA_OBJECT structure. */
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_OBJECT {                        // Table 2:31
    unsigned    Reserved_bit_at_0        : 1;
    unsigned    fixedTPM                 : 1;
    unsigned    stClear                  : 1;
    unsigned    Reserved_bit_at_3        : 1;
    unsigned    fixedParent              : 1;
    unsigned    sensitiveDataOrigin      : 1;
    unsigned    userWithAuth             : 1;
    unsigned    adminWithPolicy          : 1;
    unsigned    Reserved_bits_at_8       : 2;
    unsigned    noDA                     : 1;
    unsigned    encryptedDuplication     : 1;
    unsigned    Reserved_bits_at_12      : 4;
    unsigned    restricted               : 1;
    unsigned    decrypt                  : 1;
    unsigned    sign                     : 1;
    unsigned    x509sign                 : 1;
    unsigned    Reserved_bits_at_20      : 12;
} __attribute__((packed)) TPMA_OBJECT;
// This is the initializer for a TPMA_OBJECT structure
#define TPMA_OBJECT_INITIALIZER(					\
				bit_at_0,             fixedtpm,             stclear, \
				bit_at_3,             fixedparent,          sensitivedataorigin, \
				userwithauth,         adminwithpolicy,      bits_at_8, \
				noda,                 encryptedduplication, bits_at_12, \
				restricted,           decrypt,              sign, \
				x509sign,             bits_at_20)	\
	   {bit_at_0,             fixedtpm,             stclear,		\
	    bit_at_3,             fixedparent,          sensitivedataorigin, \
	    userwithauth,         adminwithpolicy,      bits_at_8,	\
	    noda,                 encryptedduplication, bits_at_12,	\
	    restricted,           decrypt,              sign,		\
	    x509sign,             bits_at_20}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:31 TPMA_OBJECT using bit masking
typedef UINT32                              TPMA_OBJECT;
#define TYPE_OF_TPMA_OBJECT                 UINT32
#define TPMA_OBJECT_Reserved_bit_at_0       ((TPMA_OBJECT)1 << 0)
#define TPMA_OBJECT_fixedTPM                ((TPMA_OBJECT)1 << 1)
#define TPMA_OBJECT_stClear                 ((TPMA_OBJECT)1 << 2)
#define TPMA_OBJECT_fixedParent             ((TPMA_OBJECT)1 << 4)
#define TPMA_OBJECT_sensitiveDataOrigin     ((TPMA_OBJECT)1 << 5)
#define TPMA_OBJECT_userWithAuth            ((TPMA_OBJECT)1 << 6)
#define TPMA_OBJECT_adminWithPolicy         ((TPMA_OBJECT)1 << 7)
#define TPMA_OBJECT_noDA                    ((TPMA_OBJECT)1 << 10)
#define TPMA_OBJECT_encryptedDuplication    ((TPMA_OBJECT)1 << 11)
#define TPMA_OBJECT_restricted              ((TPMA_OBJECT)1 << 16)
#define TPMA_OBJECT_decrypt                 ((TPMA_OBJECT)1 << 17)
#define TPMA_OBJECT_sign                    ((TPMA_OBJECT)1 << 18)
#define TPMA_OBJECT_x509sign                ((TPMA_OBJECT)1 << 19)
#define TPMA_OBJECT_reserved		    ((TPMA_OBJECT)0xfff0f309)
//  This is the initializer for a TPMA_OBJECT bit array.
#define TPMA_OBJECT_INITIALIZER(                                                   \
             bit_at_0,             fixedtpm,             stclear,                  \
             bit_at_3,             fixedparent,          sensitivedataorigin,      \
             userwithauth,         adminwithpolicy,      bits_at_8,                \
             noda,                 encryptedduplication, bits_at_12,               \
             restricted,           decrypt,              sign,                     \
             x509sign,             bits_at_20)                                     \
            {(fixedtpm << 1)              + (stclear << 2)               +         \
             (fixedparent << 4)           + (sensitivedataorigin << 5)   +         \
             (userwithauth << 6)          + (adminwithpolicy << 7)       +         \
             (noda << 10)                 + (encryptedduplication << 11) +         \
             (restricted << 16)           + (decrypt << 17)              +         \
             (sign << 18)                 + (x509sign << 19)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_SESSION    BYTE
#define TPMA_SESSION_TO_BYTE(a)     (*((BYTE *)&(a)))
#define BYTE_TO_TPMA_SESSION(a)     (*((TPMA_SESSION *)&(a)))
#define TPMA_SESSION_TO_BYTE_ARRAY(i, a)                                           \
            BYTE_TO_BYTE_ARRAY((TPMA_SESSION_TO_BYTE(i)), (a))
#define BYTE_ARRAY_TO_TPMA_SESSION(i, a)                                           \
            { BYTE x = BYTE_ARRAY_TO_BYTE(a); i = BYTE_TO_TPMA_SESSION(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_SESSION {                       // Table 2:32
    unsigned    continueSession      : 1;
    unsigned    auditExclusive       : 1;
    unsigned    auditReset           : 1;
    unsigned    Reserved_bits_at_3   : 2;
    unsigned    decrypt              : 1;
    unsigned    encrypt              : 1;
    unsigned    audit                : 1;
} __attribute__((packed)) TPMA_SESSION;
// This is the initializer for a TPMA_SESSION structure
#define TPMA_SESSION_INITIALIZER(					\
				 continuesession, auditexclusive,  auditreset,      bits_at_3, \
				 decrypt,         encrypt,         audit) \
    {continuesession, auditexclusive,  auditreset,      bits_at_3,	\
	    decrypt,         encrypt,         audit}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:32 TPMA_SESSION using bit masking
typedef BYTE                           TPMA_SESSION;
#define TYPE_OF_TPMA_SESSION            BYTE
#define TPMA_SESSION_continueSession    ((TPMA_SESSION)1 << 0)
#define TPMA_SESSION_auditExclusive     ((TPMA_SESSION)1 << 1)
#define TPMA_SESSION_auditReset         ((TPMA_SESSION)1 << 2)
#define TPMA_SESSION_decrypt            ((TPMA_SESSION)1 << 5)
#define TPMA_SESSION_encrypt            ((TPMA_SESSION)1 << 6)
#define TPMA_SESSION_audit              ((TPMA_SESSION)1 << 7)
#define TPMA_SESSION_reserved		    0x18
// This is the initializer for a TPMA_SESSION bit array.
#define TPMA_SESSION_INITIALIZER(					\
				 continuesession, auditexclusive,  auditreset,      bits_at_3, \
				 decrypt,         encrypt,         audit) \
           {(continuesession << 0) + (auditexclusive << 1)  +			\
	    (auditreset << 2)      + (decrypt << 5)         +		\
	    (encrypt << 6)         + (audit << 7)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_LOCALITY   BYTE
#define TPMA_LOCALITY_TO_BYTE(a)    (*((BYTE *)&(a)))
#define BYTE_TO_TPMA_LOCALITY(a)    (*((TPMA_LOCALITY *)&(a)))
#define TPMA_LOCALITY_TO_BYTE_ARRAY(i, a)                                          \
            BYTE_TO_BYTE_ARRAY((TPMA_LOCALITY_TO_BYTE(i)), (a))
#define BYTE_ARRAY_TO_TPMA_LOCALITY(i, a)                                          \
            { BYTE x = BYTE_ARRAY_TO_BYTE(a); i = BYTE_TO_TPMA_LOCALITY(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_LOCALITY {                      // Table 2:33
    unsigned    TPM_LOC_ZERO         : 1;
    unsigned    TPM_LOC_ONE          : 1;
    unsigned    TPM_LOC_TWO          : 1;
    unsigned    TPM_LOC_THREE        : 1;
    unsigned    TPM_LOC_FOUR         : 1;
    unsigned    Extended             : 3;
} __attribute__((packed)) TPMA_LOCALITY;
// This is the initializer for a TPMA_LOCALITY structure
#define TPMA_LOCALITY_INITIALIZER(					\
				  tpm_loc_zero,  tpm_loc_one,   tpm_loc_two,   tpm_loc_three, \
				  tpm_loc_four,  extended)		\
    {tpm_loc_zero,  tpm_loc_one,   tpm_loc_two,   tpm_loc_three,	\
	    tpm_loc_four,  extended}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:33 TPMA_LOCALITY using bit masking
typedef BYTE                           TPMA_LOCALITY;
#define TYPE_OF_TPMA_LOCALITY           BYTE
#define TPMA_LOCALITY_TPM_LOC_ZERO      ((TPMA_LOCALITY)1 << 0)
#define TPMA_LOCALITY_TPM_LOC_ONE       ((TPMA_LOCALITY)1 << 1)
#define TPMA_LOCALITY_TPM_LOC_TWO       ((TPMA_LOCALITY)1 << 2)
#define TPMA_LOCALITY_TPM_LOC_THREE     ((TPMA_LOCALITY)1 << 3)
#define TPMA_LOCALITY_TPM_LOC_FOUR      ((TPMA_LOCALITY)1 << 4)
#define TPMA_LOCALITY_Extended_SHIFT    5
#define TPMA_LOCALITY_Extended          ((TPMA_LOCALITY)0x7 << 5)
// This is the initializer for a TPMA_LOCALITY bit array.
#define TPMA_LOCALITY_INITIALIZER(					\
				  tpm_loc_zero,  tpm_loc_one,   tpm_loc_two,   tpm_loc_three, \
				  tpm_loc_four,  extended)		\
           {(tpm_loc_zero << 0)  + (tpm_loc_one << 1)   + (tpm_loc_two << 2)   + \
	    (tpm_loc_three << 3) + (tpm_loc_four << 4)  + (extended << 5)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_PERMANENT  UINT32
#define TPMA_PERMANENT_TO_UINT32(a)  (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_PERMANENT(a)  (*((TPMA_PERMANENT *)&(a)))
#define TPMA_PERMANENT_TO_BYTE_ARRAY(i, a)				\
	            UINT32_TO_BYTE_ARRAY((TPMA_PERMANENT_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_PERMANENT(i, a)				\
    {UINT32 x = BYTE_ARRAY_TO_UINT32(a);				\
	i = UINT32_TO_TPMA_PERMANENT(x);				\
    }

/* Table 2:34 - Definition of TPMA_PERMANENT Bits (BitsTable()) */
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_PERMANENT {                     // Table 2:34
    unsigned    ownerAuthSet         : 1;
    unsigned    endorsementAuthSet   : 1;
    unsigned    lockoutAuthSet       : 1;
    unsigned    Reserved_bits_at_3   : 5;
    unsigned    disableClear         : 1;
    unsigned    inLockout            : 1;
    unsigned    tpmGeneratedEPS      : 1;
    unsigned    Reserved_bits_at_11  : 21;
} __attribute__((packed)) TPMA_PERMANENT;
// This is the initializer for a TPMA_PERMANENT structure
#define TPMA_PERMANENT_INITIALIZER(					\
				   ownerauthset,       endorsementauthset, lockoutauthset, \
				   bits_at_3,          disableclear,       inlockout, \
				   tpmgeneratedeps,    bits_at_11)	\
    {ownerauthset,       endorsementauthset, lockoutauthset,		\
	    bits_at_3,          disableclear,       inlockout,		\
	    tpmgeneratedeps,    bits_at_11}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:34 TPMA_PERMANENT using bit masking
typedef UINT32                              TPMA_PERMANENT;
#define TYPE_OF_TPMA_PERMANENT              UINT32
#define TPMA_PERMANENT_ownerAuthSet         ((TPMA_PERMANENT)1 << 0)
#define TPMA_PERMANENT_endorsementAuthSet   ((TPMA_PERMANENT)1 << 1)
#define TPMA_PERMANENT_lockoutAuthSet       ((TPMA_PERMANENT)1 << 2)
#define TPMA_PERMANENT_disableClear         ((TPMA_PERMANENT)1 << 8)
#define TPMA_PERMANENT_inLockout            ((TPMA_PERMANENT)1 << 9)
#define TPMA_PERMANENT_tpmGeneratedEPS      ((TPMA_PERMANENT)1 << 10)
// This is the initializer for a TPMA_PERMANENT bit array.
#define TPMA_PERMANENT_INITIALIZER(					\
				   ownerauthset,       endorsementauthset, lockoutauthset, \
				   bits_at_3,          disableclear,       inlockout, \
				   tpmgeneratedeps,    bits_at_11)	\
    {(ownerauthset << 0)       + (endorsementauthset << 1) +		\
	    (lockoutauthset << 2)     + (disableclear << 8)       +	\
	    (inlockout << 9)          + (tpmgeneratedeps << 10)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_STARTUP_CLEAR  UINT32
#define TPMA_STARTUP_CLEAR_TO_UINT32(a)  (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_STARTUP_CLEAR(a)  (*((TPMA_STARTUP_CLEAR *)&(a)))
#define TPMA_STARTUP_CLEAR_TO_BYTE_ARRAY(i, a)				\
    UINT32_TO_BYTE_ARRAY((TPMA_STARTUP_CLEAR_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_STARTUP_CLEAR(i, a)				\
    {UINT32 x = BYTE_ARRAY_TO_UINT32(a);				\
	i = UINT32_TO_TPMA_STARTUP_CLEAR(x);				\
    }

/* Table 2:35 - Definition of TPMA_STARTUP_CLEAR Bits */
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_STARTUP_CLEAR {                 // Table 2:35
    unsigned    phEnable             : 1;
    unsigned    shEnable             : 1;
    unsigned    ehEnable             : 1;
    unsigned    phEnableNV           : 1;
    unsigned    Reserved_bits_at_4   : 27;
    unsigned    orderly              : 1;
} __attribute__((packed)) TPMA_STARTUP_CLEAR;
// This is the initializer for a TPMA_STARTUP_CLEAR structure
#define TPMA_STARTUP_CLEAR_INITIALIZER(					\
				       phenable, shenable, ehenable, phenablenv, bits_at_4, orderly) \
    {phenable, shenable, ehenable, phenablenv, bits_at_4, orderly}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:35 TPMA_STARTUP_CLEAR using bit masking
typedef UINT32                          TPMA_STARTUP_CLEAR;
#define TYPE_OF_TPMA_STARTUP_CLEAR      UINT32
#define TPMA_STARTUP_CLEAR_phEnable     ((TPMA_STARTUP_CLEAR)1 << 0)
#define TPMA_STARTUP_CLEAR_shEnable     ((TPMA_STARTUP_CLEAR)1 << 1)
#define TPMA_STARTUP_CLEAR_ehEnable     ((TPMA_STARTUP_CLEAR)1 << 2)
#define TPMA_STARTUP_CLEAR_phEnableNV   ((TPMA_STARTUP_CLEAR)1 << 3)
#define TPMA_STARTUP_CLEAR_orderly      ((TPMA_STARTUP_CLEAR)1 << 31)
// This is the initializer for a TPMA_STARTUP_CLEAR bit array.
#define TPMA_STARTUP_CLEAR_INITIALIZER(					\
				       phenable, shenable, ehenable, phenablenv, bits_at_4, orderly) \
    {(phenable << 0)   + (shenable << 1)   + (ehenable << 2)   +	\
	    (phenablenv << 3) + (orderly << 31)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_MEMORY UINT32
#define TPMA_MEMORY_TO_UINT32(a)     (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_MEMORY(a)     (*((TPMA_MEMORY *)&(a)))
#define TPMA_MEMORY_TO_BYTE_ARRAY(i, a)                                            \
            UINT32_TO_BYTE_ARRAY((TPMA_MEMORY_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_MEMORY(i, a)                                            \
            { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_MEMORY(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_MEMORY {                        // Table 2:36
    unsigned    sharedRAM            : 1;
    unsigned    sharedNV             : 1;
    unsigned    objectCopiedToRam    : 1;
    unsigned    Reserved_bits_at_3   : 29;
} __attribute__((packed)) TPMA_MEMORY;
// This is the initializer for a TPMA_MEMORY structure
#define TPMA_MEMORY_INITIALIZER(					\
				sharedram, sharednv, objectcopiedtoram, bits_at_3) \
    {sharedram, sharednv, objectcopiedtoram, bits_at_3}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:36 TPMA_MEMORY using bit masking
typedef UINT32                          TPMA_MEMORY;
#define TYPE_OF_TPMA_MEMORY             UINT32
#define TPMA_MEMORY_sharedRAM           ((TPMA_MEMORY)1 << 0)
#define TPMA_MEMORY_sharedNV            ((TPMA_MEMORY)1 << 1)
#define TPMA_MEMORY_objectCopiedToRam   ((TPMA_MEMORY)1 << 2)
// This is the initializer for a TPMA_MEMORY bit array.
#define TPMA_MEMORY_INITIALIZER(					\
				sharedram, sharednv, objectcopiedtoram, bits_at_3) \
    {(sharedram << 0) + (sharednv << 1) + (objectcopiedtoram << 2)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_CC     UINT32
#define TPMA_CC_TO_UINT32(a)     (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_CC(a)     (*((TPMA_CC *)&(a)))
#define TPMA_CC_TO_BYTE_ARRAY(i, a)                                                \
            UINT32_TO_BYTE_ARRAY((TPMA_CC_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_CC(i, a)                                                \
            { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_CC(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_CC {                            // Table 2:37
    unsigned    commandIndex         : 16;
    unsigned    Reserved_bits_at_16  : 6;
    unsigned    nv                   : 1;
    unsigned    extensive            : 1;
    unsigned    flushed              : 1;
    unsigned    cHandles             : 3;
    unsigned    rHandle              : 1;
    unsigned    V                    : 1;
    unsigned    Reserved_bits_at_30  : 2;
} __attribute__((packed)) TPMA_CC;
// This is the initializer for a TPMA_CC structure
#define TPMA_CC_INITIALIZER(						\
			    commandindex, bits_at_16,   nv,           extensive,    flushed, \
			    chandles,     rhandle,      v,            bits_at_30) \
    {commandindex, bits_at_16,   nv,           extensive,    flushed,	\
	    chandles,     rhandle,      v,            bits_at_30}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:37 TPMA_CC using bit masking
typedef UINT32                      TPMA_CC;
#define TYPE_OF_TPMA_CC             UINT32
#define TPMA_CC_commandIndex_SHIFT  0
#define TPMA_CC_commandIndex        ((TPMA_CC)0xffff << 0)
#define TPMA_CC_nv                  ((TPMA_CC)1 << 22)
#define TPMA_CC_extensive           ((TPMA_CC)1 << 23)
#define TPMA_CC_flushed             ((TPMA_CC)1 << 24)
#define TPMA_CC_cHandles_SHIFT      25
#define TPMA_CC_cHandles            ((TPMA_CC)0x7 << 25)
#define TPMA_CC_rHandle             ((TPMA_CC)1 << 28)
#define TPMA_CC_V                   ((TPMA_CC)1 << 29)
#define TPMA_CC_reserved	    0xc03f0000
// This is the initializer for a TPMA_CC bit array.
#define TPMA_CC_INITIALIZER(						\
			    commandindex, bits_at_16,   nv,           extensive,    flushed, \
			    chandles,     rhandle,      v,            bits_at_30) \
    (commandindex << 0) + (nv << 22)          + (extensive << 23)   +	\
     (flushed << 24)     + (chandles << 25)    + (rhandle << 28)     +	\
	    (v << 29)
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_MODES  UINT32
#define TPMA_MODES_TO_UINT32(a)  (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_MODES(a)  (*((TPMA_MODES *)&(a)))
#define TPMA_MODES_TO_BYTE_ARRAY(i, a)                                             \
            UINT32_TO_BYTE_ARRAY((TPMA_MODES_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_MODES(i, a)                                             \
            { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_MODES(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_MODES {                         // Table 2:38
    unsigned    FIPS_140_2           : 1;
    unsigned    Reserved_bits_at_1   : 31;
} __attribute__((packed)) TPMA_MODES;
// This is the initializer for a TPMA_MODES structure
#define TPMA_MODES_INITIALIZER(fips_140_2, bits_at_1) {fips_140_2, bits_at_1}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:38 TPMA_MODES using bit masking
typedef UINT32                  TPMA_MODES;
#define TYPE_OF_TPMA_MODES      UINT32
#define TPMA_MODES_FIPS_140_2   ((TPMA_MODES)1 << 0)
// This is the initializer for a TPMA_MODES bit array.
#define TPMA_MODES_INITIALIZER(fips_140_2, bits_at_1) {(fips_140_2 << 0)}
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_X509_KEY_USAGE UINT32
#define TPMA_X509_KEY_USAGE_TO_UINT32(a)     (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_X509_KEY_USAGE(a)     (*((TPMA_X509_KEY_USAGE *)&(a)))
#define TPMA_X509_KEY_USAGE_TO_BYTE_ARRAY(i, a)				\
    UINT32_TO_BYTE_ARRAY((TPMA_X509_KEY_USAGE_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_X509_KEY_USAGE(i, a)				\
    {UINT32 x = BYTE_ARRAY_TO_UINT32(a);				\
	i = UINT32_TO_TPMA_X509_KEY_USAGE(x);				\
    }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_X509_KEY_USAGE {                // Table 2:39
    unsigned    Reserved_bits_at_0   : 23;
    unsigned    decipherOnly         : 1;
    unsigned    encipherOnly         : 1;
    unsigned    cRLSign              : 1;
    unsigned    keyCertSign          : 1;
    unsigned    keyAgreement         : 1;
    unsigned    dataEncipherment     : 1;
    unsigned    keyEncipherment      : 1;
    unsigned    nonrepudiation       : 1;
    unsigned    digitalSignature     : 1;
} __attribute__((packed)) TPMA_X509_KEY_USAGE;                              /* Bits */
// This is the initializer for a TPMA_X509_KEY_USAGE structure
#define TPMA_X509_KEY_USAGE_INITIALIZER(                                           \
             bits_at_0,        decipheronly,     encipheronly,                     \
             cRLSign,          keycertsign,      keyagreement,                     \
             dataencipherment, keyencipherment,  nonrepudiation,                   \
             digitalsignature)                                                     \
            {bits_at_0,        decipheronly,     encipheronly,                     \
             cRLSign,          keycertsign,      keyagreement,                     \
             dataencipherment, keyencipherment,  nonrepudiation,                   \
             digitalsignature}
#else // USE_BIT_FIELD_STRUCTURES
/* This implements Table 2:39 TPMA_X509_KEY_USAGE using bit masking */
typedef UINT32                                  TPMA_X509_KEY_USAGE;
#define TYPE_OF_TPMA_X509_KEY_USAGE             UINT32
#define TPMA_X509_KEY_USAGE_decipherOnly        ((TPMA_X509_KEY_USAGE)1 << 23)
#define TPMA_X509_KEY_USAGE_encipherOnly        ((TPMA_X509_KEY_USAGE)1 << 24)
#define TPMA_X509_KEY_USAGE_cRLSign             ((TPMA_X509_KEY_USAGE)1 << 25)
#define TPMA_X509_KEY_USAGE_keyCertSign         ((TPMA_X509_KEY_USAGE)1 << 26)
#define TPMA_X509_KEY_USAGE_keyAgreement        ((TPMA_X509_KEY_USAGE)1 << 27)
#define TPMA_X509_KEY_USAGE_dataEncipherment    ((TPMA_X509_KEY_USAGE)1 << 28)
#define TPMA_X509_KEY_USAGE_keyEncipherment     ((TPMA_X509_KEY_USAGE)1 << 29)
#define TPMA_X509_KEY_USAGE_nonrepudiation      ((TPMA_X509_KEY_USAGE)1 << 30)
#define TPMA_X509_KEY_USAGE_digitalSignature    ((TPMA_X509_KEY_USAGE)1 << 31)
//  This is the initializer for a TPMA_X509_KEY_USAGE bit array.
#define TPMA_X509_KEY_USAGE_INITIALIZER(                                           \
             bits_at_0,        decipheronly,     encipheronly,                     \
             cRLSign,          keycertsign,      keyagreement,                     \
             dataencipherment, keyencipherment,  nonrepudiation,                   \
             digitalsignature)                                                     \
    ((decipheronly << 23)     + (encipheronly << 24)     +		\
     (cRLSign << 25)          + (keycertsign << 26)      +		\
     (keyagreement << 27)     + (dataencipherment << 28) +		\
     (keyencipherment << 29)  + (nonrepudiation << 30)   +		\
     (digitalsignature << 31))
#endif // USE_BIT_FIELD_STRUCTURES

#define TYPE_OF_TPMA_ACT    UINT32
#define TPMA_ACT_TO_UINT32(a)    (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_ACT(a)    (*((TPMA_ACT *)&(a)))
#define TPMA_ACT_TO_BYTE_ARRAY(i, a)					\
    UINT32_TO_BYTE_ARRAY((TPMA_ACT_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_ACT(i, a)					\
    { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_ACT(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_ACT {                           // Table 2:40
    unsigned    signaled             : 1;
    unsigned    preserveSignaled     : 1;
    unsigned    Reserved_bits_at_2   : 30;
} __attribute__((packed)) TPMA_ACT;                                         /* Bits */
// This is the initializer for a TPMA_ACT structure
#define TPMA_ACT_INITIALIZER(signaled, preservesignaled, bits_at_2)	\
    {signaled, preservesignaled, bits_at_2}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:40 TPMA_ACT using bit masking
typedef UINT32                      TPMA_ACT;
#define TYPE_OF_TPMA_ACT            UINT32
#define TPMA_ACT_signaled           ((TPMA_ACT)1 << 0)
#define TPMA_ACT_preserveSignaled   ((TPMA_ACT)1 << 1)
// This is the initializer for a TPMA_ACT bit array.
#define TPMA_ACT_INITIALIZER(signaled, preservesignaled, bits_at_2)	\
    {(signaled << 0) + (preservesignaled << 1)}
#endif // USE_BIT_FIELD_STRUCTURES

/* Table 2:39 - Definition of TPMI_YES_NO Type  */
typedef  BYTE               TPMI_YES_NO;
/* Table 2:40 - Definition of TPMI_DH_OBJECT Type  */
typedef  TPM_HANDLE         TPMI_DH_OBJECT;
/* Table 2:41 - Definition of TPMI_DH_PARENT Type  */
typedef  TPM_HANDLE         TPMI_DH_PARENT;
/* Table 2:42 - Definition of TPMI_DH_PERSISTENT Type  */
typedef  TPM_HANDLE         TPMI_DH_PERSISTENT;
/* Table 2:43 - Definition of TPMI_DH_ENTITY Type  */
typedef  TPM_HANDLE         TPMI_DH_ENTITY;
/* Table 2:44 - Definition of TPMI_DH_PCR Type  */
typedef  TPM_HANDLE         TPMI_DH_PCR;
/* Table 2:45 - Definition of TPMI_SH_AUTH_SESSION Type  */
typedef  TPM_HANDLE         TPMI_SH_AUTH_SESSION;
/* Table 2:46 - Definition of TPMI_SH_HMAC Type  */
typedef  TPM_HANDLE         TPMI_SH_HMAC;
/* Table 2:47 - Definition of TPMI_SH_POLICY Type  */
typedef  TPM_HANDLE         TPMI_SH_POLICY;
/* Table 2:48 - Definition of TPMI_DH_CONTEXT Type  */
typedef  TPM_HANDLE         TPMI_DH_CONTEXT;
/* Table 49 - Definition of (TPM_HANDLE) TPMI_DH_SAVED Type  */
typedef  TPM_HANDLE         TPMI_DH_SAVED;
/* Table 2:49 - Definition of TPMI_RH_HIERARCHY Type  */
typedef  TPM_HANDLE         TPMI_RH_HIERARCHY;
/* Table 2:50 - Definition of TPMI_RH_ENABLES Type  */
typedef  TPM_HANDLE         TPMI_RH_ENABLES;
/* Table 2:51 - Definition of TPMI_RH_HIERARCHY_AUTH Type  */
typedef  TPM_HANDLE         TPMI_RH_HIERARCHY_AUTH;
/* Table 2:55 - Definition of TPMI_RH_HIERARCHY_POLICY Type  */
typedef  TPM_HANDLE         TPMI_RH_HIERARCHY_POLICY;
/* Table 2:52 - Definition of TPMI_RH_PLATFORM Type  */
typedef  TPM_HANDLE         TPMI_RH_PLATFORM;
/* Table 2:53 - Definition of TPMI_RH_OWNER Type  */
typedef  TPM_HANDLE         TPMI_RH_OWNER;
/* Table 2:54 - Definition of TPMI_RH_ENDORSEMENT Type  */
typedef  TPM_HANDLE         TPMI_RH_ENDORSEMENT;
/* Table 2:55 - Definition of TPMI_RH_PROVISION Type  */
typedef  TPM_HANDLE         TPMI_RH_PROVISION;
/* Table 2:56 - Definition of TPMI_RH_CLEAR Type  */
typedef  TPM_HANDLE         TPMI_RH_CLEAR;
/* Table 2:57 - Definition of TPMI_RH_NV_AUTH Type  */
typedef  TPM_HANDLE         TPMI_RH_NV_AUTH;
/* Table 2:58 - Definition of TPMI_RH_LOCKOUT Type  */
typedef  TPM_HANDLE         TPMI_RH_LOCKOUT;
/* Table 2:59 - Definition of TPMI_RH_NV_INDEX Type  */
typedef  TPM_HANDLE         TPMI_RH_NV_INDEX;
/* Table 2:60 - Definition of TPMI_RH_AC Type  */
typedef  TPM_HANDLE         TPMI_RH_AC;
/* Table 2:65 - Definition of TPMI_RH_ACT Type  */
typedef  TPM_HANDLE         TPMI_RH_ACT;
/* Table 2:61 - Definition of TPMI_ALG_HASH Type  */
typedef  TPM_ALG_ID         TPMI_ALG_HASH;
/* Table 2:62 - Definition of TPMI_ALG_ASYM Type  */
typedef  TPM_ALG_ID         TPMI_ALG_ASYM;
/* Table 2:63 - Definition of TPMI_ALG_SYM Type  */
typedef  TPM_ALG_ID         TPMI_ALG_SYM;
/* Table 2:64 - Definition of TPMI_ALG_SYM_OBJECT Type  */
typedef  TPM_ALG_ID         TPMI_ALG_SYM_OBJECT;
/* Table 2:65 - Definition of TPMI_ALG_SYM_MODE Type  */
typedef  TPM_ALG_ID         TPMI_ALG_SYM_MODE;
/* Table 2:66 - Definition of TPMI_ALG_KDF Type  */
typedef  TPM_ALG_ID         TPMI_ALG_KDF;
/* Table 2:67 - Definition of TPMI_ALG_SIG_SCHEME Type  */
typedef  TPM_ALG_ID         TPMI_ALG_SIG_SCHEME;
/* Table 2:68 - Definition of TPMI_ECC_KEY_EXCHANGE Type  */
typedef  TPM_ALG_ID         TPMI_ECC_KEY_EXCHANGE;
/* Table 2:69 - Definition of TPMI_ST_COMMAND_TAG Type  */
typedef  TPM_ST             TPMI_ST_COMMAND_TAG;
/* Table 2:70 - Definition of TPMI_ALG_MAC_SCHEME Type */
typedef  TPM_ALG_ID         TPMI_ALG_MAC_SCHEME;
/* le 2:70 - Definition of TPMI_ALG_CIPHER_MODE Type */
typedef  TPM_ALG_ID         TPMI_ALG_CIPHER_MODE;
/* Table 2:70 - Definition of TPMS_EMPTY Structure  */
typedef BYTE TPMS_EMPTY;
/* Table 2:71 - Definition of TPMS_ALGORITHM_DESCRIPTION Structure  */
typedef struct {
    TPM_ALG_ID              alg;
    TPMA_ALGORITHM          attributes;
} __attribute__((packed)) TPMS_ALGORITHM_DESCRIPTION;
/* Table 2:71 - Definition of TPMU_HA Union  */
typedef union{
#if 	ALG_SHA1
    BYTE                    sha1[SHA1_DIGEST_SIZE];
#endif   // ALG_SHA1
// #if 	ALG_SHA256
//     BYTE                    sha256[SHA256_DIGEST_SIZE];
// #endif   // ALG_SHA256
// #if 	ALG_SHA384
//     BYTE                    sha384[SHA384_DIGEST_SIZE];
// #endif   // ALG_SHA384
// #if 	ALG_SHA512
//     BYTE                    sha512[SHA512_DIGEST_SIZE];
// #endif   // ALG_SHA512
#if 	ALG_SM3_256
    BYTE                    sm3_256[SM3_256_DIGEST_SIZE];
#endif   // ALG_SM3_256
#if ALG_SHA3_256
    BYTE                    sha3_256[SHA3_256_DIGEST_SIZE];
#endif // ALG_SHA3_256
#if ALG_SHA3_384
    BYTE                    sha3_384[SHA3_384_DIGEST_SIZE];
#endif // ALG_SHA3_384
#if ALG_SHA3_512
    BYTE                    sha3_512[SHA3_512_DIGEST_SIZE];
#endif // ALG_SHA3_512
} __attribute__((packed)) TPMU_HA;
/* Table 2:72 - Definition of TPMT_HA Structure  */
typedef struct {
    TPMI_ALG_HASH           hashAlg;
    TPMU_HA                 digest;
} __attribute__((packed)) TPMT_HA;
/* Table 2:73 - Definition of TPM2B_DIGEST Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[sizeof(TPMU_HA)];
//     }            t;
//     TPM2B        b;
// } TPM2B_DIGEST;
typedef struct tpm2b_digest
{
        TPM2B        b;
} __attribute__((packed)) RECORD(TPM2_PCR, TPM2B_DIGEST);
typedef RECORD(TPM2_PCR, TPM2B_DIGEST) TPM2B_DIGEST;
// /* Table 2:74 - Definition of TPM2B_DATA Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[sizeof(TPMT_HA)];
//     }            t;
//     TPM2B        b;
// } TPM2B_DATA;
typedef struct tpm2b_data
{
        TPM2B        b;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPM2B_DATA);
typedef RECORD(TPM2_AUTH, TPM2B_DATA) TPM2B_DATA;
// /* Table 2:75 - Definition of Types for TPM2B_NONCE */
typedef  TPM2B_DIGEST       TPM2B_NONCE;
// /* Table 2:76 - Definition of Types for TPM2B_AUTH */
typedef  TPM2B_DIGEST       TPM2B_AUTH;
// /* Table 2:77 - Definition of Types for TPM2B_OPERAND */
typedef  TPM2B_DIGEST       TPM2B_OPERAND;
/* Table 2:78 - Definition of TPM2B_EVENT Structure  */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    buffer[1024];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_EVENT;
/* Table 2:79 - Definition of TPM2B_MAX_BUFFER Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_DIGEST_BUFFER];
//     }            t;
//     TPM2B        b;
// } TPM2B_MAX_BUFFER;
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_MAX_BUFFER;
/* Table 2:80 - Definition of TPM2B_MAX_NV_BUFFER Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_NV_BUFFER_SIZE];
//     }            t;
//     TPM2B        b;
// } TPM2B_MAX_NV_BUFFER;
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_MAX_NV_BUFFER;
/* Table 2:82 - Definition of TPM2B_TIMEOUT Structure */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    buffer[sizeof(UINT64)];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_TIMEOUT;
/* Table 2:82 - Definition of TPM2B_IV Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_SYM_BLOCK_SIZE];
//     }            t;
//     TPM2B        b;
// } TPM2B_IV;
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_IV;
/* Table 2:83 - Definition of TPMU_NAME Union  */
typedef union {
    TPMT_HA                 digest;
    TPM_HANDLE              handle;
} __attribute__((packed)) TPMU_NAME;
/* Table 2:84 - Definition of TPM2B_NAME Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    name[sizeof(TPMU_NAME)];
//     }            t;
    // TPM2B        b;
// } TPM2B_NAME;
typedef struct tpm2b_name
{
    TPM2B b;
} __attribute__((packed)) RECORD(TPM2_KEY, TPM2B_NAME);
typedef RECORD(TPM2_KEY, TPM2B_NAME) TPM2B_NAME;

/* Table 2:85 - Definition of TPMS_PCR_SELECT Structure  */
// /*
// typedef struct {
//     BYTE                   sizeofSelect;
//     BYTE                    pcrSelect[PCR_SELECT_MAX];
// } TPMS_PCR_SELECT; */
typedef struct {
    BYTE                   sizeofSelect;
    BYTE                    *pcrSelect;
} __attribute__((packed)) TPMS_PCR_SELECT;
/* Table 2:86 - Definition of TPMS_PCR_SELECTION Structure  */
// typedef struct {
//     TPMI_ALG_HASH           hash;
//     BYTE                   sizeofSelect;
//     BYTE                    pcrSelect[PCR_SELECT_MAX];
// } TPMS_PCR_SELECTION;
typedef struct tpms_pcr_selection
{
        UINT16 hash;
        BYTE sizeofSelect;
        BYTE *pcrSelect;
} __attribute__((packed)) RECORD(TPM2_PCR, TPMS_PCR_SELECTION);
typedef RECORD(TPM2_PCR, TPMS_PCR_SELECTION) TPMS_PCR_SELECTION;
/* Table 2:89 - Definition of TPMT_TK_CREATION Structure  */
// typedef struct {
//     TPM_ST                  tag;
//     TPMI_RH_HIERARCHY       hierarchy;
//     TPM2B_DIGEST            digest;
// } TPMT_TK_CREATION;
/* Table 2:89 - Definition of TPMT_TK_CREATION Structure  */
typedef struct tpmt_tk_creation
{
    //TODO  NOTE： tpm2_st_value 和 TPM_ST 定义在不同文件中， TPM_ST 为源码中定义； tpm2_st_value 为自定义，直接使用枚举enum tpm2_st_value 的值。
    TPM_ST tag;
    //TODO  NOTE： tpmi_rh_hierrchy 和 TPMI_RH_HIERARCHY 定义在不同文件中， TPMI_RH_HIERARCHY 为源码中定义； tpmi_rh_hierrchy 为自定义，直接使用枚举enum tpmi_rh_hierrchy 的值。
    TPMI_RH_HIERARCHY hierarchy;
    TPM2B_DIGEST digest;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPMT_TK_CREATION);
typedef RECORD(TPM2_AUTH, TPMT_TK_CREATION) TPMT_TK_CREATION;

/* Table 2:90 - Definition of TPMT_TK_VERIFIED Structure  */
typedef struct {
    TPM_ST                  tag;
    TPMI_RH_HIERARCHY       hierarchy;
    TPM2B_DIGEST            digest;
} __attribute__((packed)) TPMT_TK_VERIFIED;
/* Table 2:91 - Definition of TPMT_TK_AUTH Structure  */
typedef struct {
    TPM_ST                  tag;
    TPMI_RH_HIERARCHY       hierarchy;
    TPM2B_DIGEST            digest;
} __attribute__((packed)) TPMT_TK_AUTH;
/* Table 2:92 - Definition of TPMT_TK_HASHCHECK Structure  */
typedef struct {
    TPM_ST                  tag;
    TPMI_RH_HIERARCHY       hierarchy;
    TPM2B_DIGEST            digest;
} __attribute__((packed)) TPMT_TK_HASHCHECK;
/* Table 2:93 - Definition of TPMS_ALG_PROPERTY Structure  */
typedef struct {
    TPM_ALG_ID              alg;
    TPMA_ALGORITHM          algProperties;
} __attribute__((packed)) TPMS_ALG_PROPERTY;
/* Table 2:94 - Definition of TPMS_TAGGED_PROPERTY Structure  */
typedef struct {
    TPM_PT                  property;
    UINT32                  value;
} __attribute__((packed)) TPMS_TAGGED_PROPERTY;
/* Table 2:95 - Definition of TPMS_TAGGED_PCR_SELECT Structure  */
/* typedef struct {
    TPM_PT_PCR              tag;
    BYTE                   sizeofSelect;
    BYTE                    pcrSelect[PCR_SELECT_MAX];
} TPMS_TAGGED_PCR_SELECT; */
typedef struct {
    TPM_PT_PCR              tag;
    BYTE                   sizeofSelect;
    BYTE                    *pcrSelect;
} __attribute__((packed)) TPMS_TAGGED_PCR_SELECT;
/* Table 2:96 - Definition of TPMS_TAGGED_POLICY Structure  */
typedef struct {
    TPM_HANDLE              handle;
    TPMT_HA                 policyHash;
} __attribute__((packed)) TPMS_TAGGED_POLICY;
/* Table 105 - Definition of TPMS_ACT_DATA Structure <OUT> */
typedef struct {
    TPM_HANDLE		    handle;
    UINT32		    timeout;
    TPMA_ACT		    attributes;
} __attribute__((packed)) TPMS_ACT_DATA;
/* Table 2:97 - Definition of TPML_CC Structure  */
typedef struct {
    UINT32                  count;
    TPM_CC                  commandCodes[MAX_CAP_CC];
} __attribute__((packed)) TPML_CC;
/* Table 2:98 - Definition of TPML_CCA Structure  */
typedef struct {
    UINT32                  count;
    TPMA_CC                 commandAttributes[MAX_CAP_CC];
} __attribute__((packed)) TPML_CCA;
/* Table 2:99 - Definition of TPML_ALG Structure  */
typedef struct {
    UINT32                  count;
    TPM_ALG_ID              algorithms[MAX_ALG_LIST_SIZE];
} __attribute__((packed)) TPML_ALG;
/* Table 2:100 - Definition of TPML_HANDLE Structure  */
typedef struct {
    UINT32                  count;
    TPM_HANDLE              handle[MAX_CAP_HANDLES];
} __attribute__((packed)) TPML_HANDLE;
/* Table 2:101 - Definition of TPML_DIGEST Structure  */
// typedef struct {
//     UINT32                  count;
//     TPM2B_DIGEST            digests[8];
// } TPML_DIGEST;
typedef struct tpml_digest
{
        UINT32 count; // count {2:}  number of digests in the list, minimum is two. 列表中的摘要数量，最少为两个
        TPM2B_DIGEST digests[8]; // digests[count]{:8}   a list of digests. For TPM2_PolicyOR(), all digests will have been computed using the digest of the policy session. For TPM2_PCR_Read(), each digest will be the size of the digest for the bank containing the PCR. 
} __attribute__((packed)) RECORD(TPM2_PCR, TPML_DIGEST);
typedef RECORD(TPM2_PCR, TPML_DIGEST) TPML_DIGEST;
/* Table 2:102 - Definition of TPML_DIGEST_VALUES Structure  */
typedef struct {
    UINT32                  count;
    TPMT_HA                 digests[HASH_COUNT];
} __attribute__((packed)) TPML_DIGEST_VALUES;
/* Table 2:104 - Definition of TPML_PCR_SELECTION Structure  */
// typedef struct {
//     UINT32                  count;
//     TPMS_PCR_SELECTION      pcrSelections[HASH_COUNT];
// } TPML_PCR_SELECTION;
typedef struct tpml_pcr_selection
{
        int count;
        TPMS_PCR_SELECTION *pcrSelections;
} __attribute__((packed)) RECORD(TPM2_PCR, TPML_PCR_SELECTION);
typedef RECORD(TPM2_PCR, TPML_PCR_SELECTION) TPML_PCR_SELECTION;
/* Table 2:105 - Definition of TPML_ALG_PROPERTY Structure  */
typedef struct {
    UINT32                  count;
    TPMS_ALG_PROPERTY       algProperties[MAX_CAP_ALGS];
} __attribute__((packed)) TPML_ALG_PROPERTY;
/* Table 2:106 - Definition of TPML_TAGGED_TPM_PROPERTY Structure  */
typedef struct {
    UINT32                  count;
    TPMS_TAGGED_PROPERTY    tpmProperty[MAX_TPM_PROPERTIES];
} __attribute__((packed)) TPML_TAGGED_TPM_PROPERTY;
/* Table 2:107 - Definition of TPML_TAGGED_PCR_PROPERTY Structure  */
typedef struct {
    UINT32                    count;
    TPMS_TAGGED_PCR_SELECT    pcrProperty[MAX_PCR_PROPERTIES];
} __attribute__((packed)) TPML_TAGGED_PCR_PROPERTY;
/* Table 2:108 - Definition of TPML_ECC_CURVE Structure  */
typedef struct {
    UINT32                  count;
    TPM_ECC_CURVE           eccCurves[MAX_ECC_CURVES];
} __attribute__((packed)) TPML_ECC_CURVE;
/* Table 2:109 - Definition of TPML_TAGGED_POLICY Structure  */
typedef struct {
    UINT32                  count;
    TPMS_TAGGED_POLICY      policies[MAX_TAGGED_POLICIES];
} __attribute__((packed)) TPML_TAGGED_POLICY;
/* Table 2:118 - Definition of TPML_ACT_DATA Structure <OUT> */
typedef struct {
    UINT32		count;
    TPMS_ACT_DATA	actData[MAX_ACT_DATA];
} __attribute__((packed)) TPML_ACT_DATA;
/* Table 2:110 - Definition of TPMU_CAPABILITIES Union  */
typedef union {
    TPML_ALG_PROPERTY           algorithms;
    TPML_HANDLE                 handles;
    TPML_CCA                    command;
    TPML_CC                     ppCommands;
    TPML_CC                     auditCommands;
    TPML_PCR_SELECTION          assignedPCR;
    TPML_TAGGED_TPM_PROPERTY    tpmProperties;
    TPML_TAGGED_PCR_PROPERTY    pcrProperties;
#if 	ALG_ECC
    TPML_ECC_CURVE              eccCurves;
#endif   // ALG_ECC
    TPML_TAGGED_POLICY          authPolicies;
    TPML_ACT_DATA 		actData;
} __attribute__((packed)) TPMU_CAPABILITIES;
/* Table 2:111 - Definition of TPMS_CAPABILITY_DATA Structure  */
typedef struct {
    TPM_CAP                 capability;
    TPMU_CAPABILITIES       data;
} __attribute__((packed)) TPMS_CAPABILITY_DATA;
/* Table 2:112 - Definition of TPMS_CLOCK_INFO Structure  */
typedef struct {
    UINT64                  clock;
    UINT32                  resetCount;
    UINT32                  restartCount;
    TPMI_YES_NO             safe;
} __attribute__((packed)) TPMS_CLOCK_INFO;
/* Table 2:113 - Definition of TPMS_TIME_INFO Structure  */
typedef struct {
    UINT64                  time;
    TPMS_CLOCK_INFO         clockInfo;
} __attribute__((packed)) TPMS_TIME_INFO;
/* Table 2:114 - Definition of TPMS_TIME_ATTEST_INFO Structure  */
typedef struct {
    TPMS_TIME_INFO          time;
    UINT64                  firmwareVersion;
} __attribute__((packed)) TPMS_TIME_ATTEST_INFO;
/* Table 2:115 - Definition of TPMS_CERTIFY_INFO Structure  */
typedef struct {
    TPM2B_NAME              name;
    TPM2B_NAME              qualifiedName;
} __attribute__((packed)) TPMS_CERTIFY_INFO;
/* Table 2:116 - Definition of TPMS_QUOTE_INFO Structure  */
typedef struct {
    TPML_PCR_SELECTION      pcrSelect;
    TPM2B_DIGEST            pcrDigest;
} __attribute__((packed)) TPMS_QUOTE_INFO;
/* Table 2:117 - Definition of TPMS_COMMAND_AUDIT_INFO Structure  */
typedef struct {
    UINT64                  auditCounter;
    TPM_ALG_ID              digestAlg;
    TPM2B_DIGEST            auditDigest;
    TPM2B_DIGEST            commandDigest;
} __attribute__((packed)) TPMS_COMMAND_AUDIT_INFO;
/* Table 2:118 - Definition of TPMS_SESSION_AUDIT_INFO Structure  */
typedef struct {
    TPMI_YES_NO             exclusiveSession;
    TPM2B_DIGEST            sessionDigest;
} __attribute__((packed)) TPMS_SESSION_AUDIT_INFO;
/* Table 2:119 - Definition of TPMS_CREATION_INFO Structure  */
typedef struct {
    TPM2B_NAME              objectName;
    TPM2B_DIGEST            creationHash;
} __attribute__((packed)) TPMS_CREATION_INFO;
/* Table 2:120 - Definition of TPMS_NV_CERTIFY_INFO Structure  */
typedef struct {
    TPM2B_NAME              indexName;
    UINT16                  offset;
    TPM2B_MAX_NV_BUFFER     nvContents;
} __attribute__((packed)) TPMS_NV_CERTIFY_INFO;
/* Table 125 - Definition of TPMS_NV_DIGEST_CERTIFY_INFO Structure <OUT> */
typedef struct {
    TPM2B_NAME		indexName;
    TPM2B_DIGEST	nvDigest;
} __attribute__((packed)) TPMS_NV_DIGEST_CERTIFY_INFO; 
/* Table 2:121 - Definition of TPMI_ST_ATTEST Type  */
typedef  TPM_ST             TPMI_ST_ATTEST;
/* Table 2:122 - Definition of TPMU_ATTEST Union  */
typedef union {
    TPMS_CERTIFY_INFO          certify;
    TPMS_CREATION_INFO         creation;
    TPMS_QUOTE_INFO            quote;
    TPMS_COMMAND_AUDIT_INFO    commandAudit;
    TPMS_SESSION_AUDIT_INFO    sessionAudit;
    TPMS_TIME_ATTEST_INFO      time;
    TPMS_NV_CERTIFY_INFO       nv;
    TPMS_NV_DIGEST_CERTIFY_INFO	nvDigest;
} __attribute__((packed)) TPMU_ATTEST;
/* Table 2:123 - Definition of TPMS_ATTEST Structure  */
typedef struct {
    TPM_GENERATED           magic;
    TPMI_ST_ATTEST          type;
    TPM2B_NAME              qualifiedSigner;
    TPM2B_DATA              extraData;
    TPMS_CLOCK_INFO         clockInfo;
    UINT64                  firmwareVersion;
    TPMU_ATTEST             attested;
} __attribute__((packed)) TPMS_ATTEST;
/* Table 2:124 - Definition of TPM2B_ATTEST Structure  */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    attestationData[sizeof(TPMS_ATTEST)];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_ATTEST;
/* Table 2:125 - Definition of TPMS_AUTH_COMMAND Structure  */
typedef struct {
    TPMI_SH_AUTH_SESSION     sessionHandle;
    TPM2B_NONCE              nonce;
    TPMA_SESSION             sessionAttributes;
    TPM2B_AUTH               hmac;
} __attribute__((packed)) TPMS_AUTH_COMMAND;
/* Table 2:126 - Definition of TPMS_AUTH_RESPONSE Structure  */
typedef struct {
    TPM2B_NONCE             nonce;
    TPMA_SESSION            sessionAttributes;
    TPM2B_AUTH              hmac;
} __attribute__((packed)) TPMS_AUTH_RESPONSE;
/* Table 2:127 - Definition of TPMI_TDES_KEY_BITS Type  */
typedef  TPM_KEY_BITS       TPMI_TDES_KEY_BITS;
/* Table 2:127 - Definition of TPMI_AES_KEY_BITS Type  */
typedef  TPM_KEY_BITS       TPMI_AES_KEY_BITS;
/* Table 2:127 - Definition of TPMI_SM4_KEY_BITS Type  */
typedef  TPM_KEY_BITS       TPMI_SM4_KEY_BITS;
/* Table 2:127 - Definition of TPMI_CAMELLIA_KEY_BITS Type  */
typedef  TPM_KEY_BITS       TPMI_CAMELLIA_KEY_BITS;
/* Table 2:128 - Definition of TPMU_SYM_KEY_BITS Union  */
// 此联合用于收集对称加密密钥大小。
typedef union {
#if 	ALG_TDES
    TPMI_TDES_KEY_BITS        tdes;
#endif   // ALG_TDES
#if 	ALG_AES
    TPMI_AES_KEY_BITS         aes;
#endif   // ALG_AES
#if 	ALG_SM4
    TPMI_SM4_KEY_BITS         sm4;
#endif   // ALG_SM4
#if 	ALG_CAMELLIA
    TPMI_CAMELLIA_KEY_BITS    camellia;
#endif   // ALG_CAMELLIA
    TPM_KEY_BITS              sym; // 参考代码使用该条目以独立于对称算法的方式引用密钥位字段
#if 	ALG_XOR
    TPMI_ALG_HASH             xorr; // xor项是哈希算法选择器，而不是以位为单位的密钥大小。xor条目仅在用于选择参数加密值的TPMT_SYM_DEF中选择。
#endif   // ALG_XOR
} __attribute__((packed)) TPMU_SYM_KEY_BITS; 
/* Table 2:129 - Definition of TPMU_SYM_MODE Union  */
typedef union {
#if 	ALG_TDES
    TPMI_ALG_SYM_MODE       tdes;
#endif   // ALG_TDES
#if 	ALG_AES
    TPMI_ALG_SYM_MODE       aes;
#endif   // ALG_AES
#if 	ALG_SM4
    TPMI_ALG_SYM_MODE       sm4;
#endif   // ALG_SM4
#if 	ALG_CAMELLIA
    TPMI_ALG_SYM_MODE       camellia;
#endif   // ALG_CAMELLIA
    TPMI_ALG_SYM_MODE       sym;
} __attribute__((packed)) TPMU_SYM_MODE;
/* Table 2:131 - Definition of TPMT_SYM_DEF Structure  */
typedef struct {
    TPMI_ALG_SYM            algorithm;
    TPMU_SYM_KEY_BITS       keyBits;
    TPMU_SYM_MODE           mode;
} __attribute__((packed)) TPMT_SYM_DEF;
/* Table 2:132 - Definition of TPMT_SYM_DEF_OBJECT Structure  */
typedef struct {
    TPMI_ALG_SYM_OBJECT     algorithm; // 选择对称分组密码。  当在父对象的参数区域中使用时，这应该是受支持的分组密码，而不是TPM_ALG_NULL
    TPMU_SYM_KEY_BITS       keyBits; // 秘钥大小。
    TPMU_SYM_MODE           mode;  // 默认模式。 在父对象的参数区域中使用时，应为TPM_ALG_CFB。
} __attribute__((packed)) TPMT_SYM_DEF_OBJECT;
/* Table 2:133 - Definition of TPM2B_SYM_KEY Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_SYM_KEY_BYTES];
//     }            t;
//     TPM2B        b;
// } TPM2B_SYM_KEY; */
typedef struct {
    TPM2B        b;
} __attribute__((packed)) TPM2B_SYM_KEY;
/* Table 2:134 - Definition of TPMS_SYMCIPHER_PARMS Structure  */
typedef struct {
    TPMT_SYM_DEF_OBJECT     sym;
} __attribute__((packed)) TPMS_SYMCIPHER_PARMS;
/* Table 2:135 - Definition of TPM2B_LABEL Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[LABEL_MAX_BUFFER];
//     }            t;
//     TPM2B        b;
// } TPM2B_LABEL; */
typedef struct {
    TPM2B        b;
} __attribute__((packed)) TPM2B_LABEL; 
/* Table 2:136 - Definition of TPMS_DERIVE Structure  */
//This structure contains the label and context fields for a derived object. These values are used in the derivation KDF. The values in the unique field of inPublic area template take precedence over the values in the inSensitive parameter.
typedef struct {
    TPM2B_LABEL             label;
    TPM2B_LABEL             context;
} __attribute__((packed)) TPMS_DERIVE; 
/* Table 2:137 - Definition of TPM2B_DERIVE Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[sizeof(TPMS_DERIVE)];
//     }            t;
//     TPM2B        b;
// } TPM2B_DERIVE; */
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_DERIVE;
/* Table 2:138 - Definition of TPMU_SENSITIVE_CREATE Union  */
// /* typedef union {
//     BYTE                    create[MAX_SYM_DATA];
//     TPMS_DERIVE             derive;
// } TPMU_SENSITIVE_CREATE; */
typedef struct
{
    TPMS_DERIVE derive;
} __attribute__((packed)) TPMU_SENSITIVE_CREATE;
// /* Table 2:139 - Definition of TPM2B_SENSITIVE_DATA Structure  */
// typedef union {
// 	UINT16                  size;
//     struct {
// 	BYTE                    buffer[sizeof(TPMU_SENSITIVE_CREATE)];
//     }            t;
//     TPM2B        b;
// } TPM2B_SENSITIVE_DATA;

typedef struct tpm2b_sensitive_data
{
        TPM2B        b;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPM2B_SENSITIVE_DATA);
typedef RECORD(TPM2_AUTH, TPM2B_SENSITIVE_DATA) TPM2B_SENSITIVE_DATA;
/* Table 2:140 - Definition of TPMS_SENSITIVE_CREATE Structure  */
// typedef struct {
//     TPM2B_AUTH              userAuth;
//     TPM2B_SENSITIVE_DATA    data;
// } TPMS_SENSITIVE_CREATE;
typedef struct tpms_sensitive_create
{
        // /*查看TCG_TPM2_Part1 27.3.2 : userAuth . */
        TPM2B_AUTH             userAuth;
        // /*查看TCG_TPM2_Part1 27.3.3 : data . */
        TPM2B_SENSITIVE_DATA   data;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPMS_SENSITIVE_CREATE);
typedef RECORD(TPM2_AUTH, TPMS_SENSITIVE_CREATE) TPMS_SENSITIVE_CREATE;
/* Table 2:141 - Definition of TPM2B_SENSITIVE_CREATE Structure  */
// typedef struct {
//     UINT16                   size;
//     TPMS_SENSITIVE_CREATE    sensitive;
// } TPM2B_SENSITIVE_CREATE;
typedef struct tpm2b_sensitive_create
{
        UINT16                 size;
        TPMS_SENSITIVE_CREATE  sensitive;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPM2B_SENSITIVE_CREATE);
typedef RECORD(TPM2_AUTH, TPM2B_SENSITIVE_CREATE) TPM2B_SENSITIVE_CREATE;
/* Table 2:142 - Definition of TPMS_SCHEME_HASH Structure  */
typedef struct {
    TPMI_ALG_HASH           hashAlg;
} __attribute__((packed)) TPMS_SCHEME_HASH;
/* Table 2:143 - Definition of TPMS_SCHEME_ECDAA Structure  */
typedef struct {
    TPMI_ALG_HASH           hashAlg;
    UINT16                  count;
} __attribute__((packed)) TPMS_SCHEME_ECDAA;
/* Table 2:144 - Definition of TPMI_ALG_KEYEDHASH_SCHEME Type  */
typedef  TPM_ALG_ID         TPMI_ALG_KEYEDHASH_SCHEME;
/* Table 2:145 - Definition of Types for HMAC_SIG_SCHEME */
typedef  TPMS_SCHEME_HASH    TPMS_SCHEME_HMAC;
/* Table 2:146 - Definition of TPMS_SCHEME_XOR Structure  */
typedef struct {
    TPMI_ALG_HASH           hashAlg;
    TPMI_ALG_KDF            kdf;
} __attribute__((packed)) TPMS_SCHEME_XOR;
/* Table 2:147 - Definition of TPMU_SCHEME_KEYEDHASH Union  */
typedef union {
#if 	ALG_HMAC
    TPMS_SCHEME_HMAC        hmac;
#endif   // ALG_HMAC
#if 	ALG_XOR
    TPMS_SCHEME_XOR         xorr;
#endif   // ALG_XOR
} __attribute__((packed)) TPMU_SCHEME_KEYEDHASH;
/* Table 2:148 - Definition of TPMT_KEYEDHASH_SCHEME Structure  */
typedef struct {
    TPMI_ALG_KEYEDHASH_SCHEME     scheme;
    TPMU_SCHEME_KEYEDHASH         details;
} __attribute__((packed)) TPMT_KEYEDHASH_SCHEME;
/* Table 2:149 - Definition of Types for RSA Signature Schemes */
typedef  TPMS_SCHEME_HASH    TPMS_SIG_SCHEME_RSASSA;
typedef  TPMS_SCHEME_HASH    TPMS_SIG_SCHEME_RSAPSS;
/* Table 2:150 - Definition of Types for ECC Signature Schemes */
typedef  TPMS_SCHEME_HASH     TPMS_SIG_SCHEME_ECDSA;
typedef  TPMS_SCHEME_HASH     TPMS_SIG_SCHEME_SM2;
typedef  TPMS_SCHEME_HASH     TPMS_SIG_SCHEME_ECSCHNORR;
typedef  TPMS_SCHEME_ECDAA    TPMS_SIG_SCHEME_ECDAA;
/* Table 2:151 - Definition of TPMU_SIG_SCHEME Union  */
typedef union {
#if 	ALG_ECC
    TPMS_SIG_SCHEME_ECDAA        ecdaa;
#endif   // ALG_ECC
#if 	ALG_RSASSA
    TPMS_SIG_SCHEME_RSASSA       rsassa;
#endif   // ALG_RSASSA
#if 	ALG_RSAPSS
    TPMS_SIG_SCHEME_RSAPSS       rsapss;
#endif   // ALG_RSAPSS
#if 	ALG_ECDSA
    TPMS_SIG_SCHEME_ECDSA        ecdsa;
#endif   // ALG_ECDSA
#if 	ALG_SM2
    TPMS_SIG_SCHEME_SM2          sm2;
#endif   // ALG_SM2
#if 	ALG_ECSCHNORR
    TPMS_SIG_SCHEME_ECSCHNORR    ecschnorr;
#endif   // ALG_ECSCHNORR
#if 	ALG_HMAC
    TPMS_SCHEME_HMAC             hmac;
#endif   // ALG_HMAC
    TPMS_SCHEME_HASH             any;
} TPMU_SIG_SCHEME;
/* Table 2:152 - Definition of TPMT_SIG_SCHEME Structure  */
typedef struct {
    TPMI_ALG_SIG_SCHEME     scheme;
    TPMU_SIG_SCHEME         details;
} __attribute__((packed)) TPMT_SIG_SCHEME;
/* Table 2:153 - Definition of Types for Encryption Schemes */
typedef  TPMS_SCHEME_HASH    TPMS_ENC_SCHEME_OAEP;
typedef  TPMS_EMPTY          TPMS_ENC_SCHEME_RSAES;
/* Table 2:154 - Definition of Types for ECC Key Exchange */
typedef  TPMS_SCHEME_HASH    TPMS_KEY_SCHEME_ECDH;
typedef  TPMS_SCHEME_HASH    TPMS_KEY_SCHEME_ECMQV;
/* Table 2:155 - Definition of Types for KDF Schemes */
typedef  TPMS_SCHEME_HASH    TPMS_SCHEME_MGF1;
typedef  TPMS_SCHEME_HASH    TPMS_SCHEME_KDF1_SP800_56A;
typedef  TPMS_SCHEME_HASH    TPMS_SCHEME_KDF2;
typedef  TPMS_SCHEME_HASH    TPMS_SCHEME_KDF1_SP800_108;
/* Table 2:156 - Definition of TPMU_KDF_SCHEME Union  */
typedef union {
#if 	ALG_MGF1
    TPMS_SCHEME_MGF1              mgf1;
#endif   // ALG_MGF1
#if 	ALG_KDF1_SP800_56A
    TPMS_SCHEME_KDF1_SP800_56A    kdf1_sp800_56a;
#endif   // ALG_KDF1_SP800_56A
#if 	ALG_KDF2
    TPMS_SCHEME_KDF2              kdf2;
#endif   // ALG_KDF2
#if 	ALG_KDF1_SP800_108
    TPMS_SCHEME_KDF1_SP800_108    kdf1_sp800_108;
#endif   // ALG_KDF1_SP800_108
} __attribute__((packed)) TPMU_KDF_SCHEME;
/* Table 2:157 - Definition of TPMT_KDF_SCHEME Structure  */
typedef struct {
    TPMI_ALG_KDF            scheme;
    TPMU_KDF_SCHEME         details;
} __attribute__((packed)) TPMT_KDF_SCHEME;
/* Table 2:158 - Definition of TPMI_ALG_ASYM_SCHEME Type  */
typedef  TPM_ALG_ID         TPMI_ALG_ASYM_SCHEME;
/* Table 2:159 - Definition of TPMU_ASYM_SCHEME Union  */
typedef union {
#if 	ALG_ECDH
    TPMS_KEY_SCHEME_ECDH         ecdh;
#endif   // ALG_ECDH
#if 	ALG_ECMQV
    TPMS_KEY_SCHEME_ECMQV        ecmqv;
#endif   // ALG_ECMQV
#if 	ALG_ECC
    TPMS_SIG_SCHEME_ECDAA        ecdaa;
#endif   // ALG_ECC
#if 	ALG_RSASSA
    TPMS_SIG_SCHEME_RSASSA       rsassa;
#endif   // ALG_RSASSA
#if 	ALG_RSAPSS
    TPMS_SIG_SCHEME_RSAPSS       rsapss;
#endif   // ALG_RSAPSS
#if 	ALG_ECDSA
    TPMS_SIG_SCHEME_ECDSA        ecdsa;
#endif   // ALG_ECDSA
#if 	ALG_SM2
    TPMS_SIG_SCHEME_SM2          sm2;
#endif   // ALG_SM2
#if 	ALG_ECSCHNORR
    TPMS_SIG_SCHEME_ECSCHNORR    ecschnorr;
#endif   // ALG_ECSCHNORR
#if 	ALG_RSAES
    TPMS_ENC_SCHEME_RSAES        rsaes;
#endif   // ALG_RSAES
#if 	ALG_OAEP
    TPMS_ENC_SCHEME_OAEP         oaep;
#endif   // ALG_OAEP
    TPMS_SCHEME_HASH             anySig;
} __attribute__((packed)) TPMU_ASYM_SCHEME;
/* Table 2:160 - Definition of TPMT_ASYM_SCHEME Structure  */
typedef struct {
    TPMI_ALG_ASYM_SCHEME     scheme; // 任何非对称算法的所有方案类型的列表。
    TPMU_ASYM_SCHEME         details;
} __attribute__((packed)) TPMT_ASYM_SCHEME;
/* Table 2:161 - Definition of TPMI_ALG_RSA_SCHEME Type  */
typedef  TPM_ALG_ID         TPMI_ALG_RSA_SCHEME;
/* Table 2:162 - Definition of TPMT_RSA_SCHEME Structure  */
typedef struct {
    TPMI_ALG_RSA_SCHEME     scheme;
    TPMU_ASYM_SCHEME        details;
} __attribute__((packed)) TPMT_RSA_SCHEME;
/* Table 2:163 - Definition of TPMI_ALG_RSA_DECRYPT Type  */
typedef  TPM_ALG_ID         TPMI_ALG_RSA_DECRYPT;
/* Table 2:164 - Definition of TPMT_RSA_DECRYPT Structure  */
typedef struct {
    TPMI_ALG_RSA_DECRYPT     scheme;
    TPMU_ASYM_SCHEME         details;
} __attribute__((packed)) TPMT_RSA_DECRYPT;
/* Table 2:165 - Definition of TPM2B_PUBLIC_KEY_RSA Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_RSA_KEY_BYTES];
//     }            t;
//     TPM2B        b;
// } TPM2B_PUBLIC_KEY_RSA; */
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_PUBLIC_KEY_RSA;
/* Table 2:166 - Definition of TPMI_RSA_KEY_BITS Type  */
typedef  TPM_KEY_BITS       TPMI_RSA_KEY_BITS;
/* Table 2:167 - Definition of TPM2B_PRIVATE_KEY_RSA Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[RSA_PRIVATE_SIZE];
//     }            t;
//     TPM2B        b;
// } TPM2B_PRIVATE_KEY_RSA; */
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_PRIVATE_KEY_RSA;
/* Table 2:168 - Definition of TPM2B_ECC_PARAMETER Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_ECC_KEY_BYTES];
//     }            t;
//     TPM2B        b;
// } TPM2B_ECC_PARAMETER; */
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_ECC_PARAMETER;
/* Table 2:169 - Definition of TPMS_ECC_POINT Structure  */
typedef struct {
    TPM2B_ECC_PARAMETER     x;
    TPM2B_ECC_PARAMETER     y;
} __attribute__((packed)) TPMS_ECC_POINT;
/* Table 2:170 - Definition of TPM2B_ECC_POINT Structure  */
typedef struct {
    UINT16                  size;
    TPMS_ECC_POINT          point;
} __attribute__((packed)) TPM2B_ECC_POINT;
/* Table 2:171 - Definition of TPMI_ALG_ECC_SCHEME Type  */
typedef  TPM_ALG_ID         TPMI_ALG_ECC_SCHEME;
/* Table 2:172 - Definition of TPMI_ECC_CURVE Type  */
typedef  TPM_ECC_CURVE      TPMI_ECC_CURVE;
/* Table 2:173 - Definition of TPMT_ECC_SCHEME Structure  */
typedef struct {
    TPMI_ALG_ECC_SCHEME     scheme;
    TPMU_ASYM_SCHEME        details;
} __attribute__((packed)) TPMT_ECC_SCHEME;
/* Table 2:174 - Definition of TPMS_ALGORITHM_DETAIL_ECC Structure  */
typedef struct {
    TPM_ECC_CURVE           curveID;
    UINT16                  keySize;
    TPMT_KDF_SCHEME         kdf;
    TPMT_ECC_SCHEME         sign;
    TPM2B_ECC_PARAMETER     p;
    TPM2B_ECC_PARAMETER     a;
    TPM2B_ECC_PARAMETER     b;
    TPM2B_ECC_PARAMETER     gX;
    TPM2B_ECC_PARAMETER     gY;
    TPM2B_ECC_PARAMETER     n;
    TPM2B_ECC_PARAMETER     h;
} __attribute__((packed)) TPMS_ALGORITHM_DETAIL_ECC;
/* Table 2:175 - Definition of TPMS_SIGNATURE_RSA Structure  */
typedef struct {
    TPMI_ALG_HASH           hash;
    TPM2B_PUBLIC_KEY_RSA    sig;
} __attribute__((packed)) TPMS_SIGNATURE_RSA;
/* Table 2:176 - Definition of Types for Signature */
typedef  TPMS_SIGNATURE_RSA    TPMS_SIGNATURE_RSASSA;
typedef  TPMS_SIGNATURE_RSA    TPMS_SIGNATURE_RSAPSS;
/* Table 2:177 - Definition of TPMS_SIGNATURE_ECC Structure  */
typedef struct {
    TPMI_ALG_HASH           hash;
    TPM2B_ECC_PARAMETER     signatureR;
    TPM2B_ECC_PARAMETER     signatureS;
} __attribute__((packed)) TPMS_SIGNATURE_ECC;
/* Table 2:178 - Definition of Types for TPMS_SIGNATURE_ECC */
typedef  TPMS_SIGNATURE_ECC    TPMS_SIGNATURE_ECDAA;
typedef  TPMS_SIGNATURE_ECC    TPMS_SIGNATURE_ECDSA;
typedef  TPMS_SIGNATURE_ECC    TPMS_SIGNATURE_SM2;
typedef  TPMS_SIGNATURE_ECC    TPMS_SIGNATURE_ECSCHNORR;
/* Table 2:179 - Definition of TPMU_SIGNATURE Union  */
typedef union {
#if 	ALG_ECC
    TPMS_SIGNATURE_ECDAA        ecdaa;
#endif   // ALG_ECC
#if 	ALG_RSA
    TPMS_SIGNATURE_RSASSA       rsassa;
#endif   // ALG_RSA
#if 	ALG_RSA
    TPMS_SIGNATURE_RSAPSS       rsapss;
#endif   // ALG_RSA
#if 	ALG_ECC
    TPMS_SIGNATURE_ECDSA        ecdsa;
#endif   // ALG_ECC
#if 	ALG_ECC
    TPMS_SIGNATURE_SM2          sm2;
#endif   // ALG_ECC
#if 	ALG_ECC
    TPMS_SIGNATURE_ECSCHNORR    ecschnorr;
#endif   // ALG_ECC
#if 	ALG_HMAC
    TPMT_HA                     hmac;
#endif   // ALG_HMAC
    TPMS_SCHEME_HASH            any;
} __attribute__((packed)) TPMU_SIGNATURE;
/* Table 2:180 - Definition of TPMT_SIGNATURE Structure  */
typedef struct {
    TPMI_ALG_SIG_SCHEME     sigAlg;
    TPMU_SIGNATURE          signature;
} __attribute__((packed)) TPMT_SIGNATURE;
/* Table 2:181 - Definition of TPMU_ENCRYPTED_SECRET Union  */
typedef union {
#if 	ALG_ECC
    BYTE                    ecc[sizeof(TPMS_ECC_POINT)];
#endif   // ALG_ECC
// #if 	ALG_RSA
//     BYTE                    rsa[MAX_RSA_KEY_BYTES];
// #endif   // ALG_RSA
#if 	ALG_SYMCIPHER
    BYTE                    symmetric[sizeof(TPM2B_DIGEST)];
#endif   // ALG_SYMCIPHER
#if 	ALG_KEYEDHASH
    BYTE                    keyedHash[sizeof(TPM2B_DIGEST)];
#endif   // ALG_KEYEDHASH
} __attribute__((packed)) TPMU_ENCRYPTED_SECRET;
/* Table 2:182 - Definition of TPM2B_ENCRYPTED_SECRET Structure  */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    secret[sizeof(TPMU_ENCRYPTED_SECRET)];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_ENCRYPTED_SECRET;
/* Table 2:183 - Definition of TPMI_ALG_PUBLIC Type  */
typedef  TPM_ALG_ID         TPMI_ALG_PUBLIC;
/* Table 2:184 - Definition of TPMU_PUBLIC_ID Union  */
typedef union {
#if 	ALG_KEYEDHASH
    TPM2B_DIGEST            keyedHash;
#endif   // ALG_KEYEDHASH
#if 	ALG_SYMCIPHER
    TPM2B_DIGEST            sym;
#endif   // ALG_SYMCIPHER
#if 	ALG_RSA
    TPM2B_PUBLIC_KEY_RSA    rsa;
#endif   // ALG_RSA
#if 	ALG_ECC
    TPMS_ECC_POINT          ecc;
#endif   // ALG_ECC
    TPMS_DERIVE             derive; //only allowed for TPM2_CreateLoaded when parentHandle  is a Derivation Parent. 
} __attribute__((packed)) TPMU_PUBLIC_ID;
/* Table 2:185 - Definition of TPMS_KEYEDHASH_PARMS Structure  */
typedef struct {
    TPMT_KEYEDHASH_SCHEME     scheme;
} __attribute__((packed)) TPMS_KEYEDHASH_PARMS;
/* Table 2:186 - Definition of TPMS_ASYM_PARMS Structure  */
typedef struct {
    TPMT_SYM_DEF_OBJECT     symmetric;
    TPMT_ASYM_SCHEME        scheme;
} __attribute__((packed)) TPMS_ASYM_PARMS;
/* Table 2:187 - Definition of TPMS_RSA_PARMS Structure  */
typedef struct {
    TPMT_SYM_DEF_OBJECT     symmetric;
    TPMT_RSA_SCHEME         scheme;
    TPMI_RSA_KEY_BITS       keyBits;
    UINT32                  exponent;
} __attribute__((packed)) TPMS_RSA_PARMS;
/* Table 2:188 - Definition of TPMS_ECC_PARMS Structure  
    该结构包含素模ECC的参数。
*/
typedef struct {
    TPMT_SYM_DEF_OBJECT     symmetric; //对于限制性解密密钥，应设置为支持的对称算法、密钥大小和模式。 如果密钥不是受限解密密钥，则该字段应设置为TPM_ALG_NULL。
    /*  
        如果设置了密钥的sign属性，则该密钥应为有效的签名方案。注：如果curveID中的符号参数表示强制方案，则此字段应具有相同的值。
        如果设置了密钥的decrypt属性，则该属性应为有效的密钥交换方案或TPM_ALG_NULL。
        如果密钥是存储密钥，则此字段应为TPM_ALG_NULL。
    */
    TPMT_ECC_SCHEME         scheme;     
    TPMI_ECC_CURVE          curveID; // ECC curve ID
    /*
        从Z值生成对称密钥的可选密钥派生方案.
        如果与curveID关联的kdf参数不是TPM_ALG_NULL，则需要为NULL。注意：目前没有此参数有效的命令，在参考代码中，此字段需要设置为TPM_ALG_NULL。   
    */
    TPMT_KDF_SCHEME         kdf;
} __attribute__((packed)) TPMS_ECC_PARMS;
/* Table 2:189 - Definition of TPMU_PUBLIC_PARMS Union  
    表198 — Definition of TPMU_PUBLIC_PARMS Union :定义了可能包含在密钥的公共部分中的参数定义结构。
    如果对象可以是父对象，则第一个字段必须是TPMT_SYM_DEF_OBJECT。见11.1.7。

    “+”表示可以同时设置两个，但应设置一个。“|” 指示可选设置。
*/
typedef union {
#if 	ALG_KEYEDHASH
    TPMS_KEYEDHASH_PARMS    keyedHashDetail; // sign | decrypt | neither
#endif   // ALG_KEYEDHASH
#if 	ALG_SYMCIPHER
    TPMS_SYMCIPHER_PARMS    symDetail; // sign | decrypt | neither
#endif   // ALG_SYMCIPHER
#if 	ALG_RSA
    TPMS_RSA_PARMS          rsaDetail; // decrypt + signs
#endif   // ALG_RSA
#if 	ALG_ECC
    TPMS_ECC_PARMS          eccDetail; // decrypt + sign
#endif   // ALG_ECC
    TPMS_ASYM_PARMS         asymDetail; // RSA和ECC密钥的通用方案结构
} __attribute__((packed)) TPMU_PUBLIC_PARMS; //查看 part2 12.2.3.7  TPMU_PUBLIC_PARMS  
/* Table 2:190 - Definition of TPMT_PUBLIC_PARMS Structure  */
typedef struct {
    TPMI_ALG_PUBLIC         type;
    TPMU_PUBLIC_PARMS       parameters;
} __attribute__((packed)) TPMT_PUBLIC_PARMS;
/* Table 2:191 - Definition of TPMT_PUBLIC Structure  */
// typedef struct {
//     TPMI_ALG_PUBLIC         type;
//     TPMI_ALG_HASH           nameAlg;
//     TPMA_OBJECT             objectAttributes;
//     TPM2B_DIGEST            authPolicy;
//     TPMU_PUBLIC_PARMS       parameters;
//     TPMU_PUBLIC_ID          unique;
// } TPMT_PUBLIC;

/* Table 2:191 - Definition of TPMT_PUBLIC Structure  */
typedef struct tpmt_public 
{
    TPMI_ALG_PUBLIC         type;   //查看TCG_TPM2_Part1 27.2.2 : type . The allowed values for type are: TPM_ALG_SYMCIPHER, TPM_ALG_KEYEDHASH, TPM_ALG_RSA, or TPM_ALG_ECC. 
    TPMI_ALG_HASH           nameAlg;    //查看TCG_TPM2_Part1 27.2.3 : nameAlg .    
    // 查看TCG_TPM2_Part2  8.3  TPMA_OBJECT (Object Attributes) 
    // This contains the set of attributes of the object. These attributes are in five classes:
    // 1)  usage (sign, encrypt, restricted); 
    // 2)  authorization (userWithAuth, adminWithPolicy, noDA); 
    // 3)  duplication (fixedParent, fixedTPM, encryptedDuplication); 
    // 4)  creation (sensitiveDataOrigin); and 
    // 5)  persistence (stClear).
    TPMA_OBJECT             objectAttributes;   
    TPM2B_DIGEST            authPolicy; //查看TCG_TPM2_Part1 27.2.5 : authPolicy . If use of an object is to be gated by a policy (including PCR), the template will contain the policy hash. Otherwise, this entry will be set to the Empty Policy.
    
    // /*查看TCG_TPM2_Part1 27.2.6 : parameters . */
    //This field contains parameters that describe the details of the object indicated in type. 
    //For a Storage Key that has fixedParent SET in its objectAttributes, these parameters will be identical to the parameters of the Storage Parent. For other objects, these parameters may vary according to the type and application.
    TPMU_PUBLIC_PARMS       parameters; 

    // /*查看TCG_TPM2_Part1 27.2.7 : unique . */
    // The unique field of the template is the only field in the public area that is replaced by the TPM during the object creation process. The caller may place any value in this field as long as the structure of the value is consistent with the type field. That is, this field should be structured in the same way as the data that will be placed in this field by the TPM. The caller may also set the size of this field to zero and the TPM will replace it with a correctly sized structure. 
    // 模板的唯一字段是公共区域的唯一字段，在对象创建过程中被TPM替换。只要值的结构与类型字段一致，调用者可以在这个字段中放置任何值。也就是说，这个字段的结构应该与TPM将放在这个字段中的数据相同。调用者也可以将这个字段的大小设置为零，TPM将用一个正确大小的结构替换它。
    // /*创建参数 参考 TCG_TPM2_Part1 27.5.3 : unique . */
    TPMU_PUBLIC_ID          unique; 
} __attribute__((packed)) RECORD(TPM2_AUTH, TPMT_PUBLIC);
typedef RECORD(TPM2_AUTH, TPMT_PUBLIC) TPMT_PUBLIC; //查看TCG_TPM2_Part1 27.2 Public Area Template 

/* Table 2:192 - Definition of TPM2B_PUBLIC Structure  */
// typedef struct {
//     UINT16                  size;
//     TPMT_PUBLIC             publicArea;
// } TPM2B_PUBLIC;
/* Table 2:192 - Definition of TPM2B_PUBLIC Structure  */
typedef struct tpm2b_public
{
        UINT16 size;
        TPMT_PUBLIC publicArea;  // publicArea:the public area ;type :+TPMT_PUBLIC .the public area // NOTE:  The “+” indicates that the caller may specify that use  of TPM_ALG_NULL is allowed for nameAlg. 
} __attribute__((packed)) RECORD(TPM2_AUTH, TPM2B_PUBLIC);
typedef RECORD(TPM2_AUTH, TPM2B_PUBLIC) TPM2B_PUBLIC;
/* Table 2:193 - Definition of TPM2B_TEMPLATE Structure  */
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[sizeof(TPMT_PUBLIC)];
//     }            t;
//     TPM2B        b;
// } TPM2B_TEMPLATE;
typedef struct
{
    TPM2B b;
} __attribute__((packed)) TPM2B_TEMPLATE;
/* Table 2:194 - Definition of TPM2B_PRIVATE_VENDOR_SPECIFIC Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[PRIVATE_VENDOR_SPECIFIC_BYTES];
//     }            t;
//     TPM2B        b;
// } TPM2B_PRIVATE_VENDOR_SPECIFIC; */
// /* typedef struct
// {
//     UINT16 size;
//     BYTE buffer[SM3_256_DIGEST_SIZE];
// } TPM2B_PRIVATE_VENDOR_SPECIFIC; */
typedef struct
{
    TPM2B b;
} __attribute__((packed)) TPM2B_PRIVATE_VENDOR_SPECIFIC;
/* Table 2:195 - Definition of TPMU_SENSITIVE_COMPOSITE Union  */
typedef union {
#if 	ALG_RSA
    TPM2B_PRIVATE_KEY_RSA            rsa;
#endif   // ALG_RSA
#if 	ALG_ECC
    TPM2B_ECC_PARAMETER              ecc;
#endif   // ALG_ECC
#if 	ALG_KEYEDHASH
    TPM2B_SENSITIVE_DATA             bits;
#endif   // ALG_KEYEDHASH
#if 	ALG_SYMCIPHER
    TPM2B_SYM_KEY                    sym;
#endif   // ALG_SYMCIPHER
    TPM2B_PRIVATE_VENDOR_SPECIFIC    any;
} __attribute__((packed)) TPMU_SENSITIVE_COMPOSITE;
/* Table 2:196 - Definition of TPMT_SENSITIVE Structure  */
typedef struct {
    TPMI_ALG_PUBLIC             sensitiveType;
    TPM2B_AUTH                  authValue;
    TPM2B_DIGEST                seedValue;
    TPMU_SENSITIVE_COMPOSITE    sensitive;
} __attribute__((packed)) TPMT_SENSITIVE;
/* Table 2:197 - Definition of TPM2B_SENSITIVE Structure  */
typedef struct {
    UINT16                  size;
    TPMT_SENSITIVE          sensitiveArea;
} __attribute__((packed)) TPM2B_SENSITIVE;

// 12.3.6 _PRIVATE
// /* Table 2:198 - Definition of _PRIVATE Structure  */
// This structure is defined to size the contents of a TPM2B_PRIVATE. This structure is not directly 
// marshaled or unmarshaled. 
// For TPM2_Duplicate() and TPM2_Import(), the TPM2B_PRIVATE may contain multiply encrypted data 
// and two integrity values. In some cases, the sensitive data is not encrypted and the integrity value is not 
// present. 
// For TPM2_Load() and TPM2_Create(), integrityInner is always present. 
// If integrityInner is present, it and sensitive are encrypted as a single block. 
typedef struct {
    TPM2B_DIGEST            integrityOuter;
    TPM2B_DIGEST            integrityInner;
    TPM2B_SENSITIVE         sensitive;
} __attribute__((packed)) _PRIVATE;

/* Table 2:199 - Definition of TPM2B_PRIVATE Structure  */
// 删除 union中的TPM2B， 目前只为create，load，modify 保留 
// The TPM2B_PRIVATE structure is used as a parameter in multiple commands that create, load, and 
// modify the sensitive area of an object. 
// When the TPM returns a TPM2B_PRIVATE structure, the TPM pads the TPM2B_AUTH to its maximum 
// size.
// typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[sizeof(_PRIVATE)];
//     }            t;
//     TPM2B        b;
// } TPM2B_PRIVATE;
typedef struct
{
    TPM2B b;
} __attribute__((packed)) TPM2B_PRIVATE;

/* Table 2:203 - Definition of TPMS_ID_OBJECT Structure  */
typedef struct {
    TPM2B_DIGEST            integrityHMAC;
    TPM2B_DIGEST            encIdentity;
} __attribute__((packed)) TPMS_ID_OBJECT;
/* Table 204 - Definition of TPM2B_ID_OBJECT Structure <IN/OUT> */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    credential[sizeof(TPMS_ID_OBJECT)];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_ID_OBJECT;

#define TYPE_OF_TPM_NV_INDEX    UINT32
#define TPM_NV_INDEX_TO_UINT32(a)    (*((UINT32 *)&(a)))
#define UINT32_TO_TPM_NV_INDEX(a)    (*((TPM_NV_INDEX *)&(a)))
#define TPM_NV_INDEX_TO_BYTE_ARRAY(i, a)                                           \
            UINT32_TO_BYTE_ARRAY((TPM_NV_INDEX_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPM_NV_INDEX(i, a)                                           \
            { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPM_NV_INDEX(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPM_NV_INDEX {                       // Table 2:205
    unsigned    index                : 24;
    unsigned    RH_NV                : 8;
} __attribute__((packed)) TPM_NV_INDEX;
// This is the initializer for a TPM_NV_INDEX structure
#define TPM_NV_INDEX_INITIALIZER(index, rh_nv) {index, rh_nv}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:205 TPM_NV_INDEX using bit masking
typedef UINT32                      TPM_NV_INDEX;
#define TPM_NV_INDEX_index_SHIFT    0
#define TPM_NV_INDEX_index          ((TPM_NV_INDEX)0xffffff << 0)
#define TPM_NV_INDEX_RH_NV_SHIFT    24
#define TPM_NV_INDEX_RH_NV          ((TPM_NV_INDEX)0xff << 24)
// This is the initializer for a TPM_NV_INDEX bit array.
#define TPM_NV_INDEX_INITIALIZER(index, rh_nv) {(index << 0) + (rh_nv << 24)}
#endif // USE_BIT_FIELD_STRUCTURES

// Table 2:206 - Definition of TPM_NT Constants
typedef UINT32              TPM_NT;
#define TYPE_OF_TPM_NT      UINT32
#define TPM_NT_ORDINARY     (TPM_NT)(0x0)
#define TPM_NT_COUNTER      (TPM_NT)(0x1)
#define TPM_NT_BITS         (TPM_NT)(0x2)
#define TPM_NT_EXTEND       (TPM_NT)(0x4)
#define TPM_NT_PIN_FAIL     (TPM_NT)(0x8)
#define TPM_NT_PIN_PASS     (TPM_NT)(0x9)
// Table 2:207
typedef struct {
    UINT32                  pinCount;
    UINT32                  pinLimit;
} __attribute__((packed)) TPMS_NV_PIN_COUNTER_PARAMETERS;

#define TYPE_OF_TPMA_NV     UINT32
#define TPMA_NV_TO_UINT32(a)     (*((UINT32 *)&(a)))
#define UINT32_TO_TPMA_NV(a)     (*((TPMA_NV *)&(a)))
#define TPMA_NV_TO_BYTE_ARRAY(i, a)                                                \
            UINT32_TO_BYTE_ARRAY((TPMA_NV_TO_UINT32(i)), (a))
#define BYTE_ARRAY_TO_TPMA_NV(i, a)                                                \
            { UINT32 x = BYTE_ARRAY_TO_UINT32(a); i = UINT32_TO_TPMA_NV(x); }
#if USE_BIT_FIELD_STRUCTURES
typedef struct TPMA_NV {                            // Table 2:208
    unsigned    PPWRITE              : 1;
    unsigned    OWNERWRITE           : 1;
    unsigned    AUTHWRITE            : 1;
    unsigned    POLICYWRITE          : 1;
    unsigned    TPM_NT               : 4;
    unsigned    Reserved_bits_at_8   : 2;
    unsigned    POLICY_DELETE        : 1;
    unsigned    WRITELOCKED          : 1;
    unsigned    WRITEALL             : 1;
    unsigned    WRITEDEFINE          : 1;
    unsigned    WRITE_STCLEAR        : 1;
    unsigned    GLOBALLOCK           : 1;
    unsigned    PPREAD               : 1;
    unsigned    OWNERREAD            : 1;
    unsigned    AUTHREAD             : 1;
    unsigned    POLICYREAD           : 1;
    unsigned    Reserved_bits_at_20  : 5;
    unsigned    NO_DA                : 1;
    unsigned    ORDERLY              : 1;
    unsigned    CLEAR_STCLEAR        : 1;
    unsigned    READLOCKED           : 1;
    unsigned    WRITTEN              : 1;
    unsigned    PLATFORMCREATE       : 1;
    unsigned    READ_STCLEAR         : 1;
} TPMA_NV;
// This is the initializer for a TPMA_NV structure
#define TPMA_NV_INITIALIZER(						\
			    ppwrite,        ownerwrite,     authwrite,      policywrite, \
			    tpm_nt,         bits_at_8,      policy_delete,  writelocked, \
			    writeall,       writedefine,    write_stclear,  globallock, \
			    ppread,         ownerread,      authread,       policyread, \
			    bits_at_20,     no_da,          orderly,        clear_stclear, \
			    readlocked,     written,        platformcreate, read_stclear) \
    {ppwrite,        ownerwrite,     authwrite,      policywrite,	\
	    tpm_nt,         bits_at_8,      policy_delete,  writelocked, \
	    writeall,       writedefine,    write_stclear,  globallock, \
	    ppread,         ownerread,      authread,       policyread, \
	    bits_at_20,     no_da,          orderly,        clear_stclear, \
	    readlocked,     written,        platformcreate, read_stclear}
#else // USE_BIT_FIELD_STRUCTURES
// This implements Table 2:208 TPMA_NV using bit masking
typedef UINT32                  TPMA_NV;
#define TYPE_OF_TPMA_NV         UINT32
#define TPMA_NV_PPWRITE         ((TPMA_NV)1 << 0)
#define TPMA_NV_OWNERWRITE      ((TPMA_NV)1 << 1)
#define TPMA_NV_AUTHWRITE       ((TPMA_NV)1 << 2)
#define TPMA_NV_POLICYWRITE     ((TPMA_NV)1 << 3)
#define TPMA_NV_TPM_NT_SHIFT    4
#define TPMA_NV_TPM_NT          ((TPMA_NV)0xf << 4)
#define TPMA_NV_POLICY_DELETE   ((TPMA_NV)1 << 10)
#define TPMA_NV_WRITELOCKED     ((TPMA_NV)1 << 11)
#define TPMA_NV_WRITEALL        ((TPMA_NV)1 << 12)
#define TPMA_NV_WRITEDEFINE     ((TPMA_NV)1 << 13)
#define TPMA_NV_WRITE_STCLEAR   ((TPMA_NV)1 << 14)
#define TPMA_NV_GLOBALLOCK      ((TPMA_NV)1 << 15)
#define TPMA_NV_PPREAD          ((TPMA_NV)1 << 16)
#define TPMA_NV_OWNERREAD       ((TPMA_NV)1 << 17)
#define TPMA_NV_AUTHREAD        ((TPMA_NV)1 << 18)
#define TPMA_NV_POLICYREAD      ((TPMA_NV)1 << 19)
#define TPMA_NV_NO_DA           ((TPMA_NV)1 << 25)
#define TPMA_NV_ORDERLY         ((TPMA_NV)1 << 26)
#define TPMA_NV_CLEAR_STCLEAR   ((TPMA_NV)1 << 27)
#define TPMA_NV_READLOCKED      ((TPMA_NV)1 << 28)
#define TPMA_NV_WRITTEN         ((TPMA_NV)1 << 29)
#define TPMA_NV_PLATFORMCREATE  ((TPMA_NV)1 << 30)
#define TPMA_NV_READ_STCLEAR    ((TPMA_NV)1 << 31)
#define TPMA_NV_RESERVED        (0x00000300 | 0x01f00000)
// This is the initializer for a TPMA_NV bit array.
#define TPMA_NV_INITIALIZER(						\
			    ppwrite,        ownerwrite,     authwrite,      policywrite, \
			    tpm_nt,         bits_at_8,      policy_delete,  writelocked, \
			    writeall,       writedefine,    write_stclear,  globallock, \
			    ppread,         ownerread,      authread,       policyread, \
			    bits_at_20,     no_da,          orderly,        clear_stclear, \
			    readlocked,     written,        platformcreate, read_stclear) \
    {(ppwrite << 0)         + (ownerwrite << 1)      +			\
     (authwrite << 2)       + (policywrite << 3)     +			\
     (tpm_nt << 4)          + (policy_delete << 10)  +			\
     (writelocked << 11)    + (writeall << 12)       +			\
     (writedefine << 13)    + (write_stclear << 14)  +			\
     (globallock << 15)     + (ppread << 16)         +			\
     (ownerread << 17)      + (authread << 18)       +			\
     (policyread << 19)     + (no_da << 25)          +			\
     (orderly << 26)        + (clear_stclear << 27)  +			\
     (readlocked << 28)     + (written << 29)        +			\
     (platformcreate << 30) + (read_stclear << 31)}
#endif // USE_BIT_FIELD_STRUCTURES

/* Table 2:209 - Definition of TPMS_NV_PUBLIC Structure  */
typedef struct {
    TPMI_RH_NV_INDEX        nvIndex;
    TPMI_ALG_HASH           nameAlg;
    TPMA_NV                 attributes;
    TPM2B_DIGEST            authPolicy;
    UINT16                  dataSize;
} __attribute__((packed)) TPMS_NV_PUBLIC;
/* Table 2:207 - Definition of TPM2B_NV_PUBLIC Structure  */
typedef struct {
    UINT16                  size;
    TPMS_NV_PUBLIC          nvPublic;
} __attribute__((packed)) TPM2B_NV_PUBLIC;
/* Table 2:208 - Definition of TPM2B_CONTEXT_SENSITIVE Structure  */
// /* typedef union {
//     struct {
// 	UINT16                  size;
// 	BYTE                    buffer[MAX_CONTEXT_SIZE];
//     }            t;
//     TPM2B        b;
// } TPM2B_CONTEXT_SENSITIVE; */
typedef struct{
    TPM2B b;
} __attribute__((packed)) TPM2B_CONTEXT_SENSITIVE;
/* Table 2:209 - Definition of TPMS_CONTEXT_DATA Structure  */
typedef struct {
    TPM2B_DIGEST               integrity;
    TPM2B_CONTEXT_SENSITIVE    encrypted;
} __attribute__((packed)) TPMS_CONTEXT_DATA;
/* Table 2:210 - Definition of TPM2B_CONTEXT_DATA Structure  */
typedef union {
    struct {
	UINT16                  size;
	BYTE                    buffer[sizeof(TPMS_CONTEXT_DATA)];
    }            t;
    TPM2B        b;
} __attribute__((packed)) TPM2B_CONTEXT_DATA;
/* Table 2:211 - Definition of TPMS_CONTEXT Structure  */
typedef struct {
    UINT64                  sequence;
    TPMI_DH_SAVED           savedHandle;
    TPMI_RH_HIERARCHY       hierarchy;
    TPM2B_CONTEXT_DATA      contextBlob;
} __attribute__((packed)) TPMS_CONTEXT;
/* Table 2:213 - Definition of TPMS_CREATION_DATA Structure  */
// typedef struct {
//     TPML_PCR_SELECTION      pcrSelect;
//     TPM2B_DIGEST            pcrDigest;
//     TPMA_LOCALITY           locality;
//     TPM_ALG_ID              parentNameAlg;
//     TPM2B_NAME              parentName;
//     TPM2B_NAME              parentQualifiedName;
//     TPM2B_DATA              outsideInfo;
// } TPMS_CREATION_DATA;

/* Table 2:213 - Definition of TPMS_CREATION_DATA Structure  */
typedef struct tpms_creation_data
{
        TPML_PCR_SELECTION pcrSelect;
        TPM2B_DIGEST pcrDigest;
        //TODO  NOTE： tpma_locality 和 TPMA_LOCALITY 定义在不同文件中，TPMA_LOCALITY为源码中定义； tpma_locality为自定义，直接使用枚举enum tpma_locality 的值。
        TPMA_LOCALITY locality;
        //TODO  NOTE： tpm_alg_id 和 TPM_ALG_ID 定义在不同文件中，TPM_ALG_ID 为源码中定义； tpm_alg_id 为自定义，直接使用枚举enum tpm_alg_id 的值。
        TPM_ALG_ID parentNameAlg;
        TPM2B_NAME parentName;
        TPM2B_NAME parentQualifiedName;
        TPM2B_DATA outsideInfo;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPMS_CREATION_DATA);
typedef RECORD(TPM2_AUTH, TPMS_CREATION_DATA) TPMS_CREATION_DATA;

/* Table 2:214 - Definition of TPM2B_CREATION_DATA Structure  */
// typedef struct {
//     UINT16                  size;
//     TPMS_CREATION_DATA      creationData;
// } TPM2B_CREATION_DATA;                              /* Structure */

/* Table 2:214 - Definition of TPM2B_CREATION_DATA Structure  */
typedef struct tpm2b_creation_data
{
        UINT16 size;
        TPMS_CREATION_DATA creationData;
} __attribute__((packed)) RECORD(TPM2_AUTH, TPM2B_CREATION_DATA);
typedef RECORD(TPM2_AUTH, TPM2B_CREATION_DATA) TPM2B_CREATION_DATA;

// Table 2:220 - Definition of TPM_AT Constants
typedef UINT32              TPM_AT;
#define TYPE_OF_TPM_AT      UINT32
#define TPM_AT_ANY          (TPM_AT)(0x00000000)
#define TPM_AT_ERROR        (TPM_AT)(0x00000001)
#define TPM_AT_PV1          (TPM_AT)(0x00000002)
#define TPM_AT_VEND         (TPM_AT)(0x80000000)

// Table 2:221 - Definition of TPM_AE Constants
typedef UINT32              TPM_AE;
#define TYPE_OF_TPM_AE      UINT32
#define TPM_AE_NONE         (TPM_AE)(0x00000000)

typedef struct {                                    // Table 2:222
    TPM_AT                  tag;
    UINT32                  data;
} TPMS_AC_OUTPUT;

/* Table 2:218 - Definition of TPML_AC_CAPABILITIES Structure  */
typedef struct {
    UINT32                  count;
    TPMS_AC_OUTPUT          acCapabilities[MAX_AC_CAPABILITIES];
} TPML_AC_CAPABILITIES;


#endif
